pygments.rb 2.3.1 → 2.4.0

data/vendor/pygments-main/pygments/lexers/gdscript.py

@@ -7,7 +7,7 @@
     Modified by Daniel J. Ramirez <djrmuv@gmail.com> based on the original
     python.py.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -16,19 +16,18 @@ import re
 from pygments.lexer import RegexLexer, include, bygroups, default, words, \
     combined
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+    Number, Punctuation, Whitespace
 
 __all__ = ["GDScriptLexer"]
 
-line_re = re.compile(".*?\n")
-
 
 class GDScriptLexer(RegexLexer):
     """
-    For `GDScript source code <https://www.godotengine.org>`_.
+    For GDScript source code.
     """
 
     name = "GDScript"
+    url = 'https://www.godotengine.org'
     aliases = ["gdscript", "gd"]
     filenames = ["*.gd"]
     mimetypes = ["text/x-gdscript", "application/x-gdscript"]
@@ -36,11 +35,9 @@ class GDScriptLexer(RegexLexer):
     def innerstring_rules(ttype):
         return [
             # the old style '%s' % (...) string formatting
-            (
-                r"%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?"
-                "[hlL]?[E-GXc-giorsux%]",
-                String.Interpol,
-            ),
+            (r"%(\(\w+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?"
+             "[hlL]?[E-GXc-giorsux%]",
+             String.Interpol),
             # backslashes, quotes and formatting signs must be parsed one at a time
             (r'[^\\\'"%\n]+', ttype),
             (r'[\'"\\]', ttype),
@@ -51,239 +48,85 @@ class GDScriptLexer(RegexLexer):
 
     tokens = {
         "root": [
-            (r"\n", Text),
-            (
-                r'^(\s*)([rRuUbB]{,2})("""(?:.|\n)*?""")',
-                bygroups(Text, String.Affix, String.Doc),
-            ),
-            (
-                r"^(\s*)([rRuUbB]{,2})('''(?:.|\n)*?''')",
-                bygroups(Text, String.Affix, String.Doc),
-            ),
-            (r"[^\S\n]+", Text),
+            (r"\n", Whitespace),
+            (r'^(\s*)([rRuUbB]{,2})("""(?:.|\n)*?""")',
+             bygroups(Whitespace, String.Affix, String.Doc)),
+            (r"^(\s*)([rRuUbB]{,2})('''(?:.|\n)*?''')",
+             bygroups(Whitespace, String.Affix, String.Doc)),
+            (r"[^\S\n]+", Whitespace),
             (r"#.*$", Comment.Single),
             (r"[]{}:(),;[]", Punctuation),
-            (r"\\\n", Text),
+            (r"(\\)(\n)", bygroups(Text, Whitespace)),
             (r"\\", Text),
             (r"(in|and|or|not)\b", Operator.Word),
-            (
-                r"!=|==|<<|>>|&&|\+=|-=|\*=|/=|%=|&=|\|=|\|\||[-~+/*%=<>&^.!|$]",
-                Operator,
-            ),
+            (r"!=|==|<<|>>|&&|\+=|-=|\*=|/=|%=|&=|\|=|\|\||[-~+/*%=<>&^.!|$]",
+             Operator),
             include("keywords"),
-            (r"(func)((?:\s|\\\s)+)", bygroups(Keyword, Text), "funcname"),
-            (r"(class)((?:\s|\\\s)+)", bygroups(Keyword, Text), "classname"),
+            (r"(func)(\s+)", bygroups(Keyword, Whitespace), "funcname"),
+            (r"(class)(\s+)", bygroups(Keyword, Whitespace), "classname"),
             include("builtins"),
-            (
-                '([rR]|[uUbB][rR]|[rR][uUbB])(""")',
-                bygroups(String.Affix, String.Double),
-                "tdqs",
-            ),
-            (
-                "([rR]|[uUbB][rR]|[rR][uUbB])(''')",
-                bygroups(String.Affix, String.Single),
-                "tsqs",
-            ),
-            (
-                '([rR]|[uUbB][rR]|[rR][uUbB])(")',
-                bygroups(String.Affix, String.Double),
-                "dqs",
-            ),
-            (
-                "([rR]|[uUbB][rR]|[rR][uUbB])(')",
-                bygroups(String.Affix, String.Single),
-                "sqs",
-            ),
-            (
-                '([uUbB]?)(""")',
-                bygroups(String.Affix, String.Double),
-                combined("stringescape", "tdqs"),
-            ),
-            (
-                "([uUbB]?)(''')",
-                bygroups(String.Affix, String.Single),
-                combined("stringescape", "tsqs"),
-            ),
-            (
-                '([uUbB]?)(")',
-                bygroups(String.Affix, String.Double),
-                combined("stringescape", "dqs"),
-            ),
-            (
-                "([uUbB]?)(')",
-                bygroups(String.Affix, String.Single),
-                combined("stringescape", "sqs"),
-            ),
+            ('([rR]|[uUbB][rR]|[rR][uUbB])(""")',
+             bygroups(String.Affix, String.Double),
+             "tdqs"),
+            ("([rR]|[uUbB][rR]|[rR][uUbB])(''')",
+             bygroups(String.Affix, String.Single),
+             "tsqs"),
+            ('([rR]|[uUbB][rR]|[rR][uUbB])(")',
+             bygroups(String.Affix, String.Double),
+             "dqs"),
+            ("([rR]|[uUbB][rR]|[rR][uUbB])(')",
+             bygroups(String.Affix, String.Single),
+             "sqs"),
+            ('([uUbB]?)(""")',
+             bygroups(String.Affix, String.Double),
+             combined("stringescape", "tdqs")),
+            ("([uUbB]?)(''')",
+             bygroups(String.Affix, String.Single),
+             combined("stringescape", "tsqs")),
+            ('([uUbB]?)(")',
+             bygroups(String.Affix, String.Double),
+             combined("stringescape", "dqs")),
+            ("([uUbB]?)(')",
+             bygroups(String.Affix, String.Single),
+             combined("stringescape", "sqs")),
             include("name"),
             include("numbers"),
         ],
         "keywords": [
-            (
-                words(
-                    (
-                        "and",
-                        "in",
-                        "not",
-                        "or",
-                        "as",
-                        "breakpoint",
-                        "class",
-                        "class_name",
-                        "extends",
-                        "is",
-                        "func",
-                        "setget",
-                        "signal",
-                        "tool",
-                        "const",
-                        "enum",
-                        "export",
-                        "onready",
-                        "static",
-                        "var",
-                        "break",
-                        "continue",
-                        "if",
-                        "elif",
-                        "else",
-                        "for",
-                        "pass",
-                        "return",
-                        "match",
-                        "while",
-                        "remote",
-                        "master",
-                        "puppet",
-                        "remotesync",
-                        "mastersync",
-                        "puppetsync",
-                    ),
-                    suffix=r"\b",
-                ),
-                Keyword,
-            ),
+            (words(("and", "in", "not", "or", "as", "breakpoint", "class",
+                    "class_name", "extends", "is", "func", "setget", "signal",
+                    "tool", "const", "enum", "export", "onready", "static",
+                    "var", "break", "continue", "if", "elif", "else", "for",
+                    "pass", "return", "match", "while", "remote", "master",
+                    "puppet", "remotesync", "mastersync", "puppetsync"),
+                   suffix=r"\b"), Keyword),
         ],
         "builtins": [
-            (
-                words(
-                    (
-                        "Color8",
-                        "ColorN",
-                        "abs",
-                        "acos",
-                        "asin",
-                        "assert",
-                        "atan",
-                        "atan2",
-                        "bytes2var",
-                        "ceil",
-                        "char",
-                        "clamp",
-                        "convert",
-                        "cos",
-                        "cosh",
-                        "db2linear",
-                        "decimals",
-                        "dectime",
-                        "deg2rad",
-                        "dict2inst",
-                        "ease",
-                        "exp",
-                        "floor",
-                        "fmod",
-                        "fposmod",
-                        "funcref",
-                        "hash",
-                        "inst2dict",
-                        "instance_from_id",
-                        "is_inf",
-                        "is_nan",
-                        "lerp",
-                        "linear2db",
-                        "load",
-                        "log",
-                        "max",
-                        "min",
-                        "nearest_po2",
-                        "pow",
-                        "preload",
-                        "print",
-                        "print_stack",
-                        "printerr",
-                        "printraw",
-                        "prints",
-                        "printt",
-                        "rad2deg",
-                        "rand_range",
-                        "rand_seed",
-                        "randf",
-                        "randi",
-                        "randomize",
-                        "range",
-                        "round",
-                        "seed",
-                        "sign",
-                        "sin",
-                        "sinh",
-                        "sqrt",
-                        "stepify",
-                        "str",
-                        "str2var",
-                        "tan",
-                        "tan",
-                        "tanh",
-                        "type_exist",
-                        "typeof",
-                        "var2bytes",
-                        "var2str",
-                        "weakref",
-                        "yield",
-                    ),
-                    prefix=r"(?<!\.)",
-                    suffix=r"\b",
-                ),
-                Name.Builtin,
-            ),
-            (r"((?<!\.)(self|false|true)|(PI|TAU|NAN|INF)" r")\b", Name.Builtin.Pseudo),
-            (
-                words(
-                    (
-                        "bool",
-                        "int",
-                        "float",
-                        "String",
-                        "NodePath",
-                        "Vector2",
-                        "Rect2",
-                        "Transform2D",
-                        "Vector3",
-                        "Rect3",
-                        "Plane",
-                        "Quat",
-                        "Basis",
-                        "Transform",
-                        "Color",
-                        "RID",
-                        "Object",
-                        "NodePath",
-                        "Dictionary",
-                        "Array",
-                        "PackedByteArray",
-                        "PackedInt32Array",
-                        "PackedInt64Array",
-                        "PackedFloat32Array",
-                        "PackedFloat64Array",
-                        "PackedStringArray",
-                        "PackedVector2Array",
-                        "PackedVector3Array",
-                        "PackedColorArray",
-                        "null",
-                    ),
-                    prefix=r"(?<!\.)",
-                    suffix=r"\b",
-                ),
-                Name.Builtin.Type,
-            ),
+            (words(("Color8", "ColorN", "abs", "acos", "asin", "assert", "atan",
+                    "atan2", "bytes2var", "ceil", "char", "clamp", "convert",
+                    "cos", "cosh", "db2linear", "decimals", "dectime", "deg2rad",
+                    "dict2inst", "ease", "exp", "floor", "fmod", "fposmod",
+                    "funcref", "hash", "inst2dict", "instance_from_id", "is_inf",
+                    "is_nan", "lerp", "linear2db", "load", "log", "max", "min",
+                    "nearest_po2", "pow", "preload", "print", "print_stack",
+                    "printerr", "printraw", "prints", "printt", "rad2deg",
+                    "rand_range", "rand_seed", "randf", "randi", "randomize",
+                    "range", "round", "seed", "sign", "sin", "sinh", "sqrt",
+                    "stepify", "str", "str2var", "tan", "tan", "tanh",
+                    "type_exist", "typeof", "var2bytes", "var2str", "weakref",
+                    "yield"), prefix=r"(?<!\.)", suffix=r"\b"),
+             Name.Builtin),
+            (r"((?<!\.)(self|false|true)|(PI|TAU|NAN|INF)" r")\b",
+             Name.Builtin.Pseudo),
+            (words(("bool", "int", "float", "String", "NodePath", "Vector2",
+                    "Rect2", "Transform2D", "Vector3", "Rect3", "Plane", "Quat",
+                    "Basis", "Transform", "Color", "RID", "Object", "NodePath",
+                    "Dictionary", "Array", "PackedByteArray", "PackedInt32Array",
+                    "PackedInt64Array", "PackedFloat32Array", "PackedFloat64Array",
+                    "PackedStringArray", "PackedVector2Array", "PackedVector3Array",
+                    "PackedColorArray", "null", "void"),
+                   prefix=r"(?<!\.)", suffix=r"\b"),
+             Name.Builtin.Type),
         ],
         "numbers": [
             (r"(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?j?", Number.Float),
@@ -316,12 +159,12 @@ class GDScriptLexer(RegexLexer):
         "tdqs": [
             (r'"""', String.Double, "#pop"),
             include("strings-double"),
-            (r"\n", String.Double),
+            (r"\n", Whitespace),
         ],
         "tsqs": [
             (r"'''", String.Single, "#pop"),
             include("strings-single"),
-            (r"\n", String.Single),
+            (r"\n", Whitespace),
         ],
     }
 

data/vendor/pygments-main/pygments/lexers/go.py

@@ -4,38 +4,35 @@
 
     Lexers for the Google Go language.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
-import re
-
 from pygments.lexer import RegexLexer, bygroups, words
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+    Number, Punctuation, Whitespace
 
 __all__ = ['GoLexer']
 
 
 class GoLexer(RegexLexer):
     """
-    For `Go <http://golang.org>`_ source.
+    For Go source.
 
     .. versionadded:: 1.2
     """
     name = 'Go'
+    url = 'https://go.dev/'
     filenames = ['*.go']
     aliases = ['go', 'golang']
     mimetypes = ['text/x-gosrc']
 
-    flags = re.MULTILINE | re.UNICODE
-
     tokens = {
         'root': [
-            (r'\n', Text),
-            (r'\s+', Text),
-            (r'\\\n', Text),  # line continuations
-            (r'//(.*?)\n', Comment.Single),
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
+            (r'(\\)(\n)', bygroups(Text, Whitespace)),  # line continuations
+            (r'//(.*?)$', Comment.Single),
             (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
             (r'(import|package)\b', Keyword.Namespace),
             (r'(var|func|struct|map|chan|type|interface|const)\b',
@@ -53,7 +50,7 @@ class GoLexer(RegexLexer):
                 'int', 'int8', 'int16', 'int32', 'int64',
                 'float', 'float32', 'float64',
                 'complex64', 'complex128', 'byte', 'rune',
-                'string', 'bool', 'error', 'uintptr',
+                'string', 'bool', 'error', 'uintptr', 'any', 'comparable',
                 'print', 'println', 'panic', 'recover', 'close', 'complex',
                 'real', 'imag', 'len', 'cap', 'append', 'copy', 'delete',
                 'new', 'make'), suffix=r'\b(\()'),
@@ -63,7 +60,7 @@ class GoLexer(RegexLexer):
                 'int', 'int8', 'int16', 'int32', 'int64',
                 'float', 'float32', 'float64',
                 'complex64', 'complex128', 'byte', 'rune',
-                'string', 'bool', 'error', 'uintptr'), suffix=r'\b'),
+                'string', 'bool', 'error', 'uintptr', 'any', 'comparable'), suffix=r'\b'),
              Keyword.Type),
             # imaginary_lit
             (r'\d+i', Number),
@@ -92,7 +89,8 @@ class GoLexer(RegexLexer):
             (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
             # Tokens
             (r'(<<=|>>=|<<|>>|<=|>=|&\^=|&\^|\+=|-=|\*=|/=|%=|&=|\|=|&&|\|\|'
-             r'|<-|\+\+|--|==|!=|:=|\.\.\.|[+\-*/%&])', Operator),
+             r'|<-|\+\+|--|==|!=|:=|\.\.\.|[+\-*/%&]'
+             r'|~|\|)', Operator),
             (r'[|^<>=!()\[\]{}.,;:]', Punctuation),
             # identifier
             (r'[^\W\d]\w*', Name.Other),

data/vendor/pygments-main/pygments/lexers/grammar_notation.py

@@ -4,15 +4,13 @@
 
     Lexers for grammar notations like BNF.
 
-    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
-import re
-
 from pygments.lexer import RegexLexer, bygroups, include, this, using, words
 from pygments.token import Comment, Keyword, Literal, Name, Number, \
-    Operator, Punctuation, String, Text
+    Operator, Punctuation, String, Text, Whitespace
 
 __all__ = ['BnfLexer', 'AbnfLexer', 'JsgfLexer', 'PegLexer']
 
@@ -39,7 +37,7 @@ class BnfLexer(RegexLexer):
     * We don't distinguish any operators and punctuation except
       `::=`.
 
-    Though these desision making might cause too minimal highlighting
+    Though these decision making might cause too minimal highlighting
     and you might be disappointed, but it is reasonable for us.
 
     .. versionadded:: 2.1
@@ -67,15 +65,15 @@ class BnfLexer(RegexLexer):
 
 class AbnfLexer(RegexLexer):
     """
-    Lexer for `IETF 7405 ABNF
-    <http://www.ietf.org/rfc/rfc7405.txt>`_
-    (Updates `5234 <http://www.ietf.org/rfc/rfc5234.txt>`_)
-    grammars.
+    Lexer for IETF 7405 ABNF.
+
+    (Updates `5234 <http://www.ietf.org/rfc/rfc5234.txt>`_) grammars.
 
     .. versionadded:: 2.1
     """
 
     name = 'ABNF'
+    url = 'http://www.ietf.org/rfc/rfc7405.txt'
     aliases = ['abnf']
     filenames = ['*.abnf']
     mimetypes = ['text/x-abnf']
@@ -117,7 +115,7 @@ class AbnfLexer(RegexLexer):
             (words(_core_rules, suffix=r'\b'), Keyword),
 
             # nonterminals (ALPHA *(ALPHA / DIGIT / "-"))
-            (r'[a-zA-Z][a-zA-Z0-9-]+\b', Name.Class),
+            (r'[a-zA-Z][a-zA-Z0-9-]*\b', Name.Class),
 
             # operators
             (r'(=/|=|/)', Operator),
@@ -126,7 +124,7 @@ class AbnfLexer(RegexLexer):
             (r'[\[\]()]', Punctuation),
 
             # fallback
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'.', Text),
         ],
     }
@@ -134,18 +132,16 @@ class AbnfLexer(RegexLexer):
 
 class JsgfLexer(RegexLexer):
     """
-    For `JSpeech Grammar Format <https://www.w3.org/TR/jsgf/>`_
-    grammars.
+    For JSpeech Grammar Format grammars.
 
     .. versionadded:: 2.2
     """
     name = 'JSGF'
+    url = 'https://www.w3.org/TR/jsgf/'
     aliases = ['jsgf']
     filenames = ['*.jsgf']
     mimetypes = ['application/jsgf', 'application/x-jsgf', 'text/jsgf']
 
-    flags = re.MULTILINE | re.UNICODE
-
     tokens = {
         'root': [
             include('comments'),
@@ -154,11 +150,11 @@ class JsgfLexer(RegexLexer):
         'comments': [
             (r'/\*\*(?!/)', Comment.Multiline, 'documentation comment'),
             (r'/\*[\w\W]*?\*/', Comment.Multiline),
-            (r'//.*', Comment.Single),
+            (r'//.*$', Comment.Single),
         ],
         'non-comments': [
             (r'\A#JSGF[^;]*', Comment.Preproc),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r';', Punctuation),
             (r'[=|()\[\]*+]', Operator),
             (r'/[^/]+/', Number.Float),
@@ -183,29 +179,29 @@ class JsgfLexer(RegexLexer):
         ],
         'grammar name': [
             (r';', Punctuation, '#pop'),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'\.', Punctuation),
             (r'[^;\s.]+', Name.Namespace),
         ],
         'rulename': [
             (r'>', Punctuation, '#pop'),
             (r'\*', Punctuation),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'([^.>]+)(\s*)(\.)', bygroups(Name.Namespace, Text, Punctuation)),
             (r'[^.>]+', Name.Constant),
         ],
         'documentation comment': [
             (r'\*/', Comment.Multiline, '#pop'),
-            (r'(^\s*\*?\s*)(@(?:example|see)\s+)'
+            (r'^(\s*)(\*?)(\s*)(@(?:example|see))(\s+)'
              r'([\w\W]*?(?=(?:^\s*\*?\s*@|\*/)))',
-             bygroups(Comment.Multiline, Comment.Special,
-                      using(this, state='example'))),
+             bygroups(Whitespace, Comment.Multiline, Whitespace, Comment.Special,
+                      Whitespace, using(this, state='example'))),
             (r'(^\s*\*?\s*)(@\S*)',
              bygroups(Comment.Multiline, Comment.Special)),
             (r'[^*\n@]+|\w|\W', Comment.Multiline),
         ],
         'example': [
-            (r'\n\s*\*', Comment.Multiline),
+            (r'(\n\s*)(\*)', bygroups(Whitespace, Comment.Multiline)),
             include('non-comments'),
             (r'.', Comment.Multiline),
         ],
@@ -214,8 +210,7 @@ class JsgfLexer(RegexLexer):
 
 class PegLexer(RegexLexer):
     """
-    This lexer is for `Parsing Expression Grammars
-    <https://bford.info/pub/lang/peg.pdf>`_ (PEG).
+    This lexer is for Parsing Expression Grammars (PEG).
 
     Various implementations of PEG have made different decisions
     regarding the syntax, so let's try to be accommodating:
@@ -234,6 +229,7 @@ class PegLexer(RegexLexer):
     """
 
     name = 'PEG'
+    url = 'https://bford.info/pub/lang/peg.pdf'
     aliases = ['peg']
     filenames = ['*.peg']
     mimetypes = ['text/x-peg']
@@ -241,7 +237,7 @@ class PegLexer(RegexLexer):
     tokens = {
         'root': [
             # Comments
-            (r'#.*', Comment.Single),
+            (r'#.*$', Comment.Single),
 
             # All operators
             (r'<-|[←:=/|&!?*+^↑~]', Operator),