udxcms 1.0.10 → 1.0.11

package/dist/components/cmsComponents/sdk/lib/highlight/lib/languages/ruby.js

@@ -2,32 +2,35 @@
  * @param {string} value
  * @returns {RegExp}
  * */
+
 /**
  * @param {RegExp | string } re
  * @returns {string}
  */
 function source(re) {
-    if (!re)
-        return null;
-    if (typeof re === "string")
-        return re;
-    return re.source;
+  if (!re) return null;
+  if (typeof re === "string") return re;
+
+  return re.source;
 }
+
 /**
  * @param {RegExp | string } re
  * @returns {string}
  */
 function lookahead(re) {
-    return concat('(?=', re, ')');
+  return concat('(?=', re, ')');
 }
+
 /**
  * @param {...(RegExp | string) } args
  * @returns {string}
  */
 function concat(...args) {
-    const joined = args.map((x) => source(x)).join("");
-    return joined;
+  const joined = args.map((x) => source(x)).join("");
+  return joined;
 }
+
 /*
 Language: Ruby
 Description: Ruby is a dynamic, open source programming language with a focus on simplicity and productivity.
@@ -36,327 +39,349 @@ Author: Anton Kovalyov <anton@kovalyov.net>
 Contributors: Peter Leonov <gojpeg@yandex.ru>, Vasily Polovnyov <vast@whiteants.net>, Loren Segal <lsegal@soen.ca>, Pascal Hurni <phi@ruby-reactive.org>, Cedric Sohrauer <sohrauer@googlemail.com>
 Category: common
 */
+
 function ruby(hljs) {
-    const RUBY_METHOD_RE = '([a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?)';
-    const RUBY_KEYWORDS = {
-        keyword: 'and then defined module in return redo if BEGIN retry end for self when ' +
-            'next until do begin unless END rescue else break undef not super class case ' +
-            'require yield alias while ensure elsif or include attr_reader attr_writer attr_accessor ' +
-            '__FILE__',
-        built_in: 'proc lambda',
-        literal: 'true false nil'
-    };
-    const YARDOCTAG = {
-        className: 'doctag',
-        begin: '@[A-Za-z]+'
-    };
-    const IRB_OBJECT = {
-        begin: '#<',
-        end: '>'
-    };
-    const COMMENT_MODES = [
-        hljs.COMMENT('#', '$', {
-            contains: [YARDOCTAG]
+  const RUBY_METHOD_RE = '([a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?)';
+  const RUBY_KEYWORDS = {
+    keyword:
+      'and then defined module in return redo if BEGIN retry end for self when ' +
+      'next until do begin unless END rescue else break undef not super class case ' +
+      'require yield alias while ensure elsif or include attr_reader attr_writer attr_accessor ' +
+      '__FILE__',
+    built_in: 'proc lambda',
+    literal:
+      'true false nil'
+  };
+  const YARDOCTAG = {
+    className: 'doctag',
+    begin: '@[A-Za-z]+'
+  };
+  const IRB_OBJECT = {
+    begin: '#<',
+    end: '>'
+  };
+  const COMMENT_MODES = [
+    hljs.COMMENT(
+      '#',
+      '$',
+      {
+        contains: [ YARDOCTAG ]
+      }
+    ),
+    hljs.COMMENT(
+      '^=begin',
+      '^=end',
+      {
+        contains: [ YARDOCTAG ],
+        relevance: 10
+      }
+    ),
+    hljs.COMMENT('^__END__', '\\n$')
+  ];
+  const SUBST = {
+    className: 'subst',
+    begin: /#\{/,
+    end: /\}/,
+    keywords: RUBY_KEYWORDS
+  };
+  const STRING = {
+    className: 'string',
+    contains: [
+      hljs.BACKSLASH_ESCAPE,
+      SUBST
+    ],
+    variants: [
+      {
+        begin: /'/,
+        end: /'/
+      },
+      {
+        begin: /"/,
+        end: /"/
+      },
+      {
+        begin: /`/,
+        end: /`/
+      },
+      {
+        begin: /%[qQwWx]?\(/,
+        end: /\)/
+      },
+      {
+        begin: /%[qQwWx]?\[/,
+        end: /\]/
+      },
+      {
+        begin: /%[qQwWx]?\{/,
+        end: /\}/
+      },
+      {
+        begin: /%[qQwWx]?</,
+        end: />/
+      },
+      {
+        begin: /%[qQwWx]?\//,
+        end: /\//
+      },
+      {
+        begin: /%[qQwWx]?%/,
+        end: /%/
+      },
+      {
+        begin: /%[qQwWx]?-/,
+        end: /-/
+      },
+      {
+        begin: /%[qQwWx]?\|/,
+        end: /\|/
+      },
+      // in the following expressions, \B in the beginning suppresses recognition of ?-sequences
+      // where ? is the last character of a preceding identifier, as in: `func?4`
+      {
+        begin: /\B\?(\\\d{1,3})/
+      },
+      {
+        begin: /\B\?(\\x[A-Fa-f0-9]{1,2})/
+      },
+      {
+        begin: /\B\?(\\u\{?[A-Fa-f0-9]{1,6}\}?)/
+      },
+      {
+        begin: /\B\?(\\M-\\C-|\\M-\\c|\\c\\M-|\\M-|\\C-\\M-)[\x20-\x7e]/
+      },
+      {
+        begin: /\B\?\\(c|C-)[\x20-\x7e]/
+      },
+      {
+        begin: /\B\?\\?\S/
+      },
+      { // heredocs
+        begin: /<<[-~]?'?(\w+)\n(?:[^\n]*\n)*?\s*\1\b/,
+        returnBegin: true,
+        contains: [
+          {
+            begin: /<<[-~]?'?/
+          },
+          hljs.END_SAME_AS_BEGIN({
+            begin: /(\w+)/,
+            end: /(\w+)/,
+            contains: [
+              hljs.BACKSLASH_ESCAPE,
+              SUBST
+            ]
+          })
+        ]
+      }
+    ]
+  };
+
+  // Ruby syntax is underdocumented, but this grammar seems to be accurate
+  // as of version 2.7.2 (confirmed with (irb and `Ripper.sexp(...)`)
+  // https://docs.ruby-lang.org/en/2.7.0/doc/syntax/literals_rdoc.html#label-Numbers
+  const decimal = '[1-9](_?[0-9])*|0';
+  const digits = '[0-9](_?[0-9])*';
+  const NUMBER = {
+    className: 'number',
+    relevance: 0,
+    variants: [
+      // decimal integer/float, optionally exponential or rational, optionally imaginary
+      {
+        begin: `\\b(${decimal})(\\.(${digits}))?([eE][+-]?(${digits})|r)?i?\\b`
+      },
+
+      // explicit decimal/binary/octal/hexadecimal integer,
+      // optionally rational and/or imaginary
+      {
+        begin: "\\b0[dD][0-9](_?[0-9])*r?i?\\b"
+      },
+      {
+        begin: "\\b0[bB][0-1](_?[0-1])*r?i?\\b"
+      },
+      {
+        begin: "\\b0[oO][0-7](_?[0-7])*r?i?\\b"
+      },
+      {
+        begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*r?i?\\b"
+      },
+
+      // 0-prefixed implicit octal integer, optionally rational and/or imaginary
+      {
+        begin: "\\b0(_?[0-7])+r?i?\\b"
+      }
+    ]
+  };
+
+  const PARAMS = {
+    className: 'params',
+    begin: '\\(',
+    end: '\\)',
+    endsParent: true,
+    keywords: RUBY_KEYWORDS
+  };
+
+  const RUBY_DEFAULT_CONTAINS = [
+    STRING,
+    {
+      className: 'class',
+      beginKeywords: 'class module',
+      end: '$|;',
+      illegal: /=/,
+      contains: [
+        hljs.inherit(hljs.TITLE_MODE, {
+          begin: '[A-Za-z_]\\w*(::\\w+)*(\\?|!)?'
         }),
-        hljs.COMMENT('^=begin', '^=end', {
-            contains: [YARDOCTAG],
-            relevance: 10
+        {
+          begin: '<\\s*',
+          contains: [
+            {
+              begin: '(' + hljs.IDENT_RE + '::)?' + hljs.IDENT_RE,
+              // we already get points for <, we don't need poitns
+              // for the name also
+              relevance: 0
+            }
+          ]
+        }
+      ].concat(COMMENT_MODES)
+    },
+    {
+      className: 'function',
+      // def method_name(
+      // def method_name;
+      // def method_name (end of line)
+      begin: concat(/def\s+/, lookahead(RUBY_METHOD_RE + "\\s*(\\(|;|$)")),
+      relevance: 0, // relevance comes from kewords
+      keywords: "def",
+      end: '$|;',
+      contains: [
+        hljs.inherit(hljs.TITLE_MODE, {
+          begin: RUBY_METHOD_RE
         }),
-        hljs.COMMENT('^__END__', '\\n$')
-    ];
-    const SUBST = {
-        className: 'subst',
-        begin: /#\{/,
-        end: /\}/,
-        keywords: RUBY_KEYWORDS
-    };
-    const STRING = {
-        className: 'string',
-        contains: [
+        PARAMS
+      ].concat(COMMENT_MODES)
+    },
+    {
+      // swallow namespace qualifiers before symbols
+      begin: hljs.IDENT_RE + '::'
+    },
+    {
+      className: 'symbol',
+      begin: hljs.UNDERSCORE_IDENT_RE + '(!|\\?)?:',
+      relevance: 0
+    },
+    {
+      className: 'symbol',
+      begin: ':(?!\\s)',
+      contains: [
+        STRING,
+        {
+          begin: RUBY_METHOD_RE
+        }
+      ],
+      relevance: 0
+    },
+    NUMBER,
+    {
+      // negative-look forward attemps to prevent false matches like:
+      // @ident@ or $ident$ that might indicate this is not ruby at all
+      className: "variable",
+      begin: '(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])' + `(?![A-Za-z])(?![@$?'])`
+    },
+    {
+      className: 'params',
+      begin: /\|/,
+      end: /\|/,
+      relevance: 0, // this could be a lot of things (in other languages) other than params
+      keywords: RUBY_KEYWORDS
+    },
+    { // regexp container
+      begin: '(' + hljs.RE_STARTERS_RE + '|unless)\\s*',
+      keywords: 'unless',
+      contains: [
+        {
+          className: 'regexp',
+          contains: [
             hljs.BACKSLASH_ESCAPE,
             SUBST
-        ],
-        variants: [
-            {
-                begin: /'/,
-                end: /'/
-            },
-            {
-                begin: /"/,
-                end: /"/
-            },
-            {
-                begin: /`/,
-                end: /`/
-            },
-            {
-                begin: /%[qQwWx]?\(/,
-                end: /\)/
-            },
-            {
-                begin: /%[qQwWx]?\[/,
-                end: /\]/
-            },
-            {
-                begin: /%[qQwWx]?\{/,
-                end: /\}/
-            },
-            {
-                begin: /%[qQwWx]?</,
-                end: />/
-            },
-            {
-                begin: /%[qQwWx]?\//,
-                end: /\//
-            },
-            {
-                begin: /%[qQwWx]?%/,
-                end: /%/
-            },
-            {
-                begin: /%[qQwWx]?-/,
-                end: /-/
-            },
-            {
-                begin: /%[qQwWx]?\|/,
-                end: /\|/
-            },
-            // in the following expressions, \B in the beginning suppresses recognition of ?-sequences
-            // where ? is the last character of a preceding identifier, as in: `func?4`
-            {
-                begin: /\B\?(\\\d{1,3})/
-            },
+          ],
+          illegal: /\n/,
+          variants: [
             {
-                begin: /\B\?(\\x[A-Fa-f0-9]{1,2})/
+              begin: '/',
+              end: '/[a-z]*'
             },
             {
-                begin: /\B\?(\\u\{?[A-Fa-f0-9]{1,6}\}?)/
+              begin: /%r\{/,
+              end: /\}[a-z]*/
             },
             {
-                begin: /\B\?(\\M-\\C-|\\M-\\c|\\c\\M-|\\M-|\\C-\\M-)[\x20-\x7e]/
+              begin: '%r\\(',
+              end: '\\)[a-z]*'
             },
             {
-                begin: /\B\?\\(c|C-)[\x20-\x7e]/
+              begin: '%r!',
+              end: '![a-z]*'
             },
             {
-                begin: /\B\?\\?\S/
-            },
-            {
-                begin: /<<[-~]?'?(\w+)\n(?:[^\n]*\n)*?\s*\1\b/,
-                returnBegin: true,
-                contains: [
-                    {
-                        begin: /<<[-~]?'?/
-                    },
-                    hljs.END_SAME_AS_BEGIN({
-                        begin: /(\w+)/,
-                        end: /(\w+)/,
-                        contains: [
-                            hljs.BACKSLASH_ESCAPE,
-                            SUBST
-                        ]
-                    })
-                ]
-            }
-        ]
-    };
-    // Ruby syntax is underdocumented, but this grammar seems to be accurate
-    // as of version 2.7.2 (confirmed with (irb and `Ripper.sexp(...)`)
-    // https://docs.ruby-lang.org/en/2.7.0/doc/syntax/literals_rdoc.html#label-Numbers
-    const decimal = '[1-9](_?[0-9])*|0';
-    const digits = '[0-9](_?[0-9])*';
-    const NUMBER = {
-        className: 'number',
-        relevance: 0,
-        variants: [
-            // decimal integer/float, optionally exponential or rational, optionally imaginary
-            {
-                begin: `\\b(${decimal})(\\.(${digits}))?([eE][+-]?(${digits})|r)?i?\\b`
-            },
-            // explicit decimal/binary/octal/hexadecimal integer,
-            // optionally rational and/or imaginary
-            {
-                begin: "\\b0[dD][0-9](_?[0-9])*r?i?\\b"
-            },
-            {
-                begin: "\\b0[bB][0-1](_?[0-1])*r?i?\\b"
-            },
-            {
-                begin: "\\b0[oO][0-7](_?[0-7])*r?i?\\b"
-            },
-            {
-                begin: "\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*r?i?\\b"
-            },
-            // 0-prefixed implicit octal integer, optionally rational and/or imaginary
-            {
-                begin: "\\b0(_?[0-7])+r?i?\\b"
-            }
-        ]
-    };
-    const PARAMS = {
-        className: 'params',
-        begin: '\\(',
-        end: '\\)',
-        endsParent: true,
-        keywords: RUBY_KEYWORDS
-    };
-    const RUBY_DEFAULT_CONTAINS = [
-        STRING,
-        {
-            className: 'class',
-            beginKeywords: 'class module',
-            end: '$|;',
-            illegal: /=/,
-            contains: [
-                hljs.inherit(hljs.TITLE_MODE, {
-                    begin: '[A-Za-z_]\\w*(::\\w+)*(\\?|!)?'
-                }),
-                {
-                    begin: '<\\s*',
-                    contains: [
-                        {
-                            begin: '(' + hljs.IDENT_RE + '::)?' + hljs.IDENT_RE,
-                            // we already get points for <, we don't need poitns
-                            // for the name also
-                            relevance: 0
-                        }
-                    ]
-                }
-            ].concat(COMMENT_MODES)
-        },
-        {
-            className: 'function',
-            // def method_name(
-            // def method_name;
-            // def method_name (end of line)
-            begin: concat(/def\s+/, lookahead(RUBY_METHOD_RE + "\\s*(\\(|;|$)")),
-            relevance: 0, // relevance comes from kewords
-            keywords: "def",
-            end: '$|;',
-            contains: [
-                hljs.inherit(hljs.TITLE_MODE, {
-                    begin: RUBY_METHOD_RE
-                }),
-                PARAMS
-            ].concat(COMMENT_MODES)
-        },
-        {
-            // swallow namespace qualifiers before symbols
-            begin: hljs.IDENT_RE + '::'
-        },
-        {
-            className: 'symbol',
-            begin: hljs.UNDERSCORE_IDENT_RE + '(!|\\?)?:',
-            relevance: 0
-        },
-        {
-            className: 'symbol',
-            begin: ':(?!\\s)',
-            contains: [
-                STRING,
-                {
-                    begin: RUBY_METHOD_RE
-                }
-            ],
-            relevance: 0
-        },
-        NUMBER,
-        {
-            // negative-look forward attemps to prevent false matches like:
-            // @ident@ or $ident$ that might indicate this is not ruby at all
-            className: "variable",
-            begin: '(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])' + `(?![A-Za-z])(?![@$?'])`
-        },
-        {
-            className: 'params',
-            begin: /\|/,
-            end: /\|/,
-            relevance: 0, // this could be a lot of things (in other languages) other than params
-            keywords: RUBY_KEYWORDS
-        },
-        {
-            begin: '(' + hljs.RE_STARTERS_RE + '|unless)\\s*',
-            keywords: 'unless',
-            contains: [
-                {
-                    className: 'regexp',
-                    contains: [
-                        hljs.BACKSLASH_ESCAPE,
-                        SUBST
-                    ],
-                    illegal: /\n/,
-                    variants: [
-                        {
-                            begin: '/',
-                            end: '/[a-z]*'
-                        },
-                        {
-                            begin: /%r\{/,
-                            end: /\}[a-z]*/
-                        },
-                        {
-                            begin: '%r\\(',
-                            end: '\\)[a-z]*'
-                        },
-                        {
-                            begin: '%r!',
-                            end: '![a-z]*'
-                        },
-                        {
-                            begin: '%r\\[',
-                            end: '\\][a-z]*'
-                        }
-                    ]
-                }
-            ].concat(IRB_OBJECT, COMMENT_MODES),
-            relevance: 0
-        }
-    ].concat(IRB_OBJECT, COMMENT_MODES);
-    SUBST.contains = RUBY_DEFAULT_CONTAINS;
-    PARAMS.contains = RUBY_DEFAULT_CONTAINS;
-    // >>
-    // ?>
-    const SIMPLE_PROMPT = "[>?]>";
-    // irb(main):001:0>
-    const DEFAULT_PROMPT = "[\\w#]+\\(\\w+\\):\\d+:\\d+>";
-    const RVM_PROMPT = "(\\w+-)?\\d+\\.\\d+\\.\\d+(p\\d+)?[^\\d][^>]+>";
-    const IRB_DEFAULT = [
-        {
-            begin: /^\s*=>/,
-            starts: {
-                end: '$',
-                contains: RUBY_DEFAULT_CONTAINS
-            }
-        },
-        {
-            className: 'meta',
-            begin: '^(' + SIMPLE_PROMPT + "|" + DEFAULT_PROMPT + '|' + RVM_PROMPT + ')(?=[ ])',
-            starts: {
-                end: '$',
-                contains: RUBY_DEFAULT_CONTAINS
+              begin: '%r\\[',
+              end: '\\][a-z]*'
             }
+          ]
         }
-    ];
-    COMMENT_MODES.unshift(IRB_OBJECT);
-    return {
-        name: 'Ruby',
-        aliases: [
-            'rb',
-            'gemspec',
-            'podspec',
-            'thor',
-            'irb'
-        ],
-        keywords: RUBY_KEYWORDS,
-        illegal: /\/\*/,
-        contains: [
-            hljs.SHEBANG({
-                binary: "ruby"
-            })
-        ]
-            .concat(IRB_DEFAULT)
-            .concat(COMMENT_MODES)
-            .concat(RUBY_DEFAULT_CONTAINS)
-    };
+      ].concat(IRB_OBJECT, COMMENT_MODES),
+      relevance: 0
+    }
+  ].concat(IRB_OBJECT, COMMENT_MODES);
+
+  SUBST.contains = RUBY_DEFAULT_CONTAINS;
+  PARAMS.contains = RUBY_DEFAULT_CONTAINS;
+
+  // >>
+  // ?>
+  const SIMPLE_PROMPT = "[>?]>";
+  // irb(main):001:0>
+  const DEFAULT_PROMPT = "[\\w#]+\\(\\w+\\):\\d+:\\d+>";
+  const RVM_PROMPT = "(\\w+-)?\\d+\\.\\d+\\.\\d+(p\\d+)?[^\\d][^>]+>";
+
+  const IRB_DEFAULT = [
+    {
+      begin: /^\s*=>/,
+      starts: {
+        end: '$',
+        contains: RUBY_DEFAULT_CONTAINS
+      }
+    },
+    {
+      className: 'meta',
+      begin: '^(' + SIMPLE_PROMPT + "|" + DEFAULT_PROMPT + '|' + RVM_PROMPT + ')(?=[ ])',
+      starts: {
+        end: '$',
+        contains: RUBY_DEFAULT_CONTAINS
+      }
+    }
+  ];
+
+  COMMENT_MODES.unshift(IRB_OBJECT);
+
+  return {
+    name: 'Ruby',
+    aliases: [
+      'rb',
+      'gemspec',
+      'podspec',
+      'thor',
+      'irb'
+    ],
+    keywords: RUBY_KEYWORDS,
+    illegal: /\/\*/,
+    contains: [
+      hljs.SHEBANG({
+        binary: "ruby"
+      })
+    ]
+      .concat(IRB_DEFAULT)
+      .concat(COMMENT_MODES)
+      .concat(RUBY_DEFAULT_CONTAINS)
+  };
 }
+
 module.exports = ruby;