prism-code-editor/dist/grammars/ruby.js

Lightweight, extensible code editor component for the web using Prism

import { l as n, i as r } from "../prismCore-5c7f03d0.js";
import "./clike.js";
var i = n.rb = n.ruby = n.extend("clike", {
  comment: {
    pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
    greedy: !0
  },
  "class-name": {
    pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
    lookbehind: !0,
    inside: {
      punctuation: /[.\\]/
    }
  },
  keyword: /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
  operator: /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
  punctuation: /[(){}[\].,;]/
}), e = {
  pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
  lookbehind: !0,
  inside: {
    content: {
      pattern: /^(#\{)[\s\S]+(?=\}$)/,
      lookbehind: !0,
      inside: i
    },
    delimiter: {
      pattern: /^#\{|\}$/,
      alias: "punctuation"
    }
  }
}, t = "(?:" + [
  /([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
  /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source,
  /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source,
  /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source,
  /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source
].join("|") + ")", s = /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/.source;
delete i.function;
r("ruby", "operator", {
  "double-colon": {
    pattern: /::/,
    alias: "punctuation"
  }
});
r("ruby", "keyword", {
  "regex-literal": [
    {
      pattern: RegExp(`%r${t}[egimnosux]{0,6}`),
      greedy: !0,
      inside: {
        interpolation: e,
        regex: /[\s\S]+/
      }
    },
    {
      pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
      lookbehind: !0,
      greedy: !0,
      inside: {
        interpolation: e,
        regex: /[\s\S]+/
      }
    }
  ],
  variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
  symbol: [
    {
      pattern: RegExp(/(^|[^:]):/.source + s),
      lookbehind: !0,
      greedy: !0
    },
    {
      pattern: RegExp(/([\r\n{(,][ \t]*)/.source + s + /(?=:(?!:))/.source),
      lookbehind: !0,
      greedy: !0
    }
  ],
  "method-definition": {
    pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
    lookbehind: !0,
    inside: {
      function: /\b\w+$/,
      keyword: /^self\b/,
      "class-name": /^\w+/,
      punctuation: /\./
    }
  }
});
r("ruby", "string", {
  "string-literal": [
    {
      pattern: RegExp(/%[qQiIwWs]?/.source + t),
      greedy: !0,
      inside: {
        interpolation: e,
        string: /[\s\S]+/
      }
    },
    {
      pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
      greedy: !0,
      inside: {
        interpolation: e,
        string: /[\s\S]+/
      }
    },
    {
      pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
      alias: "heredoc-string",
      greedy: !0,
      inside: {
        delimiter: {
          pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
          inside: {
            symbol: /\b\w+/,
            punctuation: /^<<[-~]?/
          }
        },
        interpolation: e,
        string: /[\s\S]+/
      }
    },
    {
      pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
      alias: "heredoc-string",
      greedy: !0,
      inside: {
        delimiter: {
          pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
          inside: {
            symbol: /\b\w+/,
            punctuation: /^<<[-~]?'|'$/
          }
        },
        string: /[\s\S]+/
      }
    }
  ],
  "command-literal": [
    {
      pattern: RegExp(/%x/.source + t),
      greedy: !0,
      inside: {
        interpolation: e,
        command: {
          pattern: /[\s\S]+/,
          alias: "string"
        }
      }
    },
    {
      pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
      greedy: !0,
      inside: {
        interpolation: e,
        command: {
          pattern: /[\s\S]+/,
          alias: "string"
        }
      }
    }
  ]
});
delete i.string;
r("ruby", "number", {
  builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
  constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
});