pygments.rb 2.3.1 → 2.4.0

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

@@ -1,19 +1,18 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.apdlexer
     ~~~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for ANSYS Parametric Design 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, include, words
-from pygments.token import Comment, Keyword, Name, Text, Number, Operator, \
-    String, Generic, Punctuation
+from pygments.lexer import RegexLexer, include, words, default
+from pygments.token import Comment, Keyword, Name, Number, Operator, \
+    String, Generic, Punctuation, Whitespace, Escape
 
 __all__ = ['apdlexer']
 
@@ -145,7 +144,7 @@ class apdlexer(RegexLexer):
                "CMDELE", "CMDOMEGA", "CMEDIT", "CMGRP", "CMLIST",
                "CMMOD", "CMOMEGA", "CMPLOT", "CMROTATE", "CMSEL",
                "CMSFILE", "CMSOPT", "CMWRITE", "CNCHECK", "CNKMOD",
-               "CNTR", "CNVTOL", "/COLOR", "/COM", "*COMP", "COMBINE",
+               "CNTR", "CNVTOL", "/COLOR", "*COMP", "COMBINE",
                "COMPRESS", "CON4", "CONE", "/CONFIG", "CONJUG",
                "/CONTOUR", "/COPY", "CORIOLIS", "COUPLE", "COVAL",
                "CP", "CPCYC", "CPDELE", "CPINTF", "/CPLANE", "CPLGEN",
@@ -159,7 +158,7 @@ class apdlexer(RegexLexer):
                "DADELE", "DALIST", "DAMORPH", "DATA", "DATADEF",
                "DCGOMG", "DCUM", "DCVSWP", "DDASPEC", "DDELE",
                "DDOPTION", "DEACT", "DEFINE", "*DEL", "DELETE",
-               "/DELETE", "DELTIM", "DEMORPH", "DERIV", "DESIZE",
+               "/DELETE", "DELTIM", "DELTIME", "DEMORPH", "DERIV", "DESIZE",
                "DESOL", "DETAB", "/DEVDISP", "/DEVICE", "/DFLAB",
                "DFLX", "DFSWAVE", "DIG", "DIGIT", "*DIM",
                "/DIRECTORY", "DISPLAY", "/DIST", "DJ", "DJDELE",
@@ -351,7 +350,7 @@ class apdlexer(RegexLexer):
                "SSBT", "/SSCALE", "SSLN", "SSMT", "SSPA", "SSPB",
                "SSPD", "SSPE", "SSPM", "SSUM", "SSTATE", "STABILIZE",
                "STAOPT", "STAT", "*STATUS", "/STATUS", "STEF",
-               "/STITLE", "STORE", "SUBOPT", "SUBSET", "SUCALC",
+               "STORE", "SUBOPT", "SUBSET", "SUCALC",
                "SUCR", "SUDEL", "SUEVAL", "SUGET", "SUMAP", "SUMTYPE",
                "SUPL", "SUPR", "SURESU", "SUSAVE", "SUSEL", "SUVECT",
                "SV", "SVPLOT", "SVTYP", "SWADD", "SWDEL", "SWGEN",
@@ -360,13 +359,13 @@ class apdlexer(RegexLexer):
                "TBEO", "TBIN", "TBFIELD", "TBFT", "TBLE", "TBLIST",
                "TBMODIF", "TBPLOT", "TBPT", "TBTEMP", "TCHG", "/TEE",
                "TERM", "THEXPAND", "THOPT", "TIFF", "TIME",
-               "TIMERANGE", "TIMINT", "TIMP", "TINTP", "/TITLE",
+               "TIMERANGE", "TIMINT", "TIMP", "TINTP",
                "/TLABEL", "TOFFST", "*TOPER", "TORQ2D", "TORQC2D",
                "TORQSUM", "TORUS", "TRANS", "TRANSFER", "*TREAD",
                "TREF", "/TRIAD", "/TRLCY", "TRNOPT", "TRPDEL",
                "TRPLIS", "TRPOIN", "TRTIME", "TSHAP", "/TSPEC",
                "TSRES", "TUNIF", "TVAR", "/TXTRE", "/TYPE", "TYPE",
-               "/UCMD", "/UDOC", "/UI", "UIMP", "/UIS", "*ULIB",
+               "/UCMD", "/UDOC", "/UI", "UIMP", "/UIS", "*ULIB", "/UPF",
                "UNDELETE", "UNDO", "/UNITS", "UNPAUSE", "UPCOORD",
                "UPGEOM", "*USE", "/USER", "USRCAL", "USRDOF",
                "USRELEM", "V", "V2DOPT", "VA", "*VABS", "VADD",
@@ -417,23 +416,168 @@ class apdlexer(RegexLexer):
                "/ANNOT", "ANORM", "ANPRES", "ANSOL", "ANSTOAQWA",
                "ANSTOASAS", "ANTIME", "ANTYPE")
 
+    special = ("/COM", "/TITLE", "STITLE")
+
+    elements = ("SOLID5",
+                "LINK11",
+                "PLANE13",
+                "COMBIN14",
+                "MASS2",
+                "PLANE25",
+                "MATRIX27",
+                "FLUID29",
+                "FLUID30",
+                "LINK31",
+                "LINK33",
+                "LINK34",
+                "PLANE35",
+                "SOURC36",
+                "COMBIN37",
+                "FLUID38",
+                "COMBIN39",
+                "COMBIN40",
+                "INFIN47",
+                "MATRIX50",
+                "PLANE55",
+                "SHELL61",
+                "LINK68",
+                "SOLID70",
+                "MASS71",
+                "PLANE75",
+                "PLANE77",
+                "PLANE78",
+                "PLANE83",
+                "SOLID87",
+                "SOLID90",
+                "CIRCU94",
+                "SOLID96",
+                "SOLID98",
+                "INFIN110",
+                "INFIN111",
+                "FLUID116",
+                "PLANE121",
+                "SOLID122",
+                "SOLID123",
+                "CIRCU124",
+                "CIRCU125",
+                "TRANS126",
+                "FLUID129",
+                "FLUID130",
+                "SHELL131",
+                "SHELL132",
+                "FLUID136",
+                "FLUID138",
+                "FLUID139",
+                "SURF151",
+                "SURF152",
+                "SURF153",
+                "SURF154",
+                "SURF155",
+                "SURF156",
+                "SHELL157",
+                "SURF159",
+                "TARGE169",
+                "TARGE170",
+                "CONTA172",
+                "CONTA174",
+                "CONTA175",
+                "CONTA177",
+                "CONTA178",
+                "PRETS179",
+                "LINK180",
+                "SHELL181",
+                "PLANE182",
+                "PLANE183",
+                "MPC184",
+                "SOLID185",
+                "SOLID186",
+                "SOLID187",
+                "BEAM188",
+                "BEAM189",
+                "SOLSH190",
+                "INTER192",
+                "INTER193",
+                "INTER194",
+                "INTER195",
+                "MESH200",
+                "FOLLW201",
+                "INTER202",
+                "INTER203",
+                "INTER204",
+                "INTER205",
+                "SHELL208",
+                "SHELL209",
+                "CPT212",
+                "CPT213",
+                "COMBI214",
+                "CPT215",
+                "CPT216",
+                "CPT217",
+                "FLUID218",
+                "FLUID220",
+                "FLUID221",
+                "PLANE222",
+                "PLANE223",
+                "SOLID225",
+                "SOLID226",
+                "SOLID227",
+                "PLANE230",
+                "SOLID231",
+                "SOLID232",
+                "PLANE233",
+                "SOLID236",
+                "SOLID237",
+                "PLANE238",
+                "SOLID239",
+                "SOLID240",
+                "HSFLD241",
+                "HSFLD242",
+                "COMBI250",
+                "SURF251",
+                "SURF252",
+                "INFIN257",
+                "REINF263",
+                "REINF264",
+                "REINF265",
+                "SOLID272",
+                "SOLID273",
+                "SOLID278",
+                "SOLID279",
+                "CABLE280",
+                "SHELL281",
+                "SOLID285",
+                "PIPE288",
+                "PIPE289",
+                "ELBOW290",
+                "SOLID291",
+                "PLANE292",
+                "PLANE293",
+                "USER300")
+
     tokens = {
         'root': [
-            (r'!.*\n', Comment),
+            (r'[^\S\n]+', Whitespace),
+            (words((elafunb+elafunc+elafund+elafune+elafunh+special), suffix=r'\b'), Keyword, 'non-keyword'),
+            default('non-keyword'),
+        ],
+        'non-keyword': [
+            (r'!.*\n', Comment, '#pop'),
+            (r'%.*?%', Escape),
             include('strings'),
-            include('core'),
             include('nums'),
-            (words((elafunb+elafunc+elafund+elafune+elafunh), suffix=r'\b'), Keyword),
             (words((elafunf+elafung), suffix=r'\b'), Name.Builtin),
+            (words((elements), suffix=r'\b'), Name.Property),
+            include('core'),
             (r'AR[0-9]+', Name.Variable.Instance),
-            (r'[a-z][a-z0-9_]*', Name.Variable),
-            (r'[\s]+', Text),
+            (r'[a-z_][a-z0-9_]*', Name.Variable),
+            (r'\n+', Whitespace, '#pop'),
+            (r'[^\S\n]+', Whitespace),
         ],
         'core': [
             # Operators
-            (r'(\*\*|\*|\+|-|\/|<|>|<=|>=|==|\/=|=)', Operator),
+            (r'(\*\*|\*|\+|-|\/|<|>|<=|>=|==|\/=|=|\(|\))', Operator),
             (r'/EOF', Generic.Emph),
-            (r'[(),:&;]', Punctuation),
+            (r'[\.(),:&;]', Punctuation),
         ],
         'strings': [
             (r'(?s)"(\\\\|\\[0-7]+|\\.|[^"\\])*"', String.Double),
@@ -441,8 +585,8 @@ class apdlexer(RegexLexer):
             (r'[$%]', String.Symbol),
         ],
         'nums': [
-            (r'\d+(?![.ef])', Number.Integer),
-            (r'[+-]?\d*\.?\d+([ef][-+]?\d+)?', Number.Float),
-            (r'[+-]?\d+\.?\d*([ef][-+]?\d+)?', Number.Float),
+            (r'[+-]?\d*\.\d+([efEF][-+]?\d+)?', Number.Float), # with dot
+            (r'([+-]?\d+([efEF][-+]?\d+))', Number.Float), # With scientific notation
+            (r'\b\d+(?![.ef])', Number.Integer), # integer simple
         ]
     }

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

@@ -4,24 +4,25 @@
 
     Lexers for APL.
 
-    :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.
 """
 
 from pygments.lexer import RegexLexer
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation
+from pygments.token import Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Whitespace
 
 __all__ = ['APLLexer']
 
 
 class APLLexer(RegexLexer):
     """
-    A simple `APL <https://en.m.wikipedia.org/wiki/APL_(programming_language)>`_ lexer.
+    A simple APL lexer.
 
     .. versionadded:: 2.0
     """
     name = 'APL'
+    url = 'https://en.m.wikipedia.org/wiki/APL_(programming_language)'
     aliases = ['apl']
     filenames = [
         '*.apl', '*.aplf', '*.aplo', '*.apln',  
@@ -32,7 +33,7 @@ class APLLexer(RegexLexer):
         'root': [
             # Whitespace
             # ==========
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             #
             # Comment
             # =======

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

@@ -13,13 +13,13 @@
     Contributed by Thomas Beale <https://github.com/wolandscat>,
     <https://bitbucket.org/thomas_beale>.
 
-    :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.
 """
 
 from pygments.lexer import RegexLexer, include, bygroups, using, default
 from pygments.token import Text, Comment, Name, Literal, Number, String, \
-    Punctuation, Keyword, Operator, Generic
+    Punctuation, Keyword, Operator, Generic, Whitespace
 
 __all__ = ['OdinLexer', 'CadlLexer', 'AdlLexer']
 
@@ -34,13 +34,14 @@ class AtomsLexer(RegexLexer):
     tokens = {
         # ----- pseudo-states for inclusion -----
         'whitespace': [
-            (r'\n', Text),
-            (r'\s+', Text),
-            (r'[ \t]*--.*$', Comment),
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
+            (r'([ \t]*)(--.*)$', bygroups(Whitespace, Comment)),
         ],
         'archetype_id': [
-            (r'[ \t]*([a-zA-Z]\w+(\.[a-zA-Z]\w+)*::)?[a-zA-Z]\w+(-[a-zA-Z]\w+){2}'
-             r'\.\w+[\w-]*\.v\d+(\.\d+){,2}((-[a-z]+)(\.\d+)?)?', Name.Decorator),
+            (r'([ \t]*)(([a-zA-Z]\w+(\.[a-zA-Z]\w+)*::)?[a-zA-Z]\w+(-[a-zA-Z]\w+){2}'
+             r'\.\w+[\w-]*\.v\d+(\.\d+){,2}((-[a-z]+)(\.\d+)?)?)',
+             bygroups(Whitespace, Name.Decorator)),
         ],
         'date_constraints': [
             # ISO 8601-based date/time constraints
@@ -107,7 +108,7 @@ class AtomsLexer(RegexLexer):
             (r'[<>=] *', Punctuation),
             # handle +/-
             (r'\+/-', Punctuation),
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
         ],
         'any_code': [
             include('archetype_id'),
@@ -120,7 +121,7 @@ class AtomsLexer(RegexLexer):
             (r'\|', Punctuation, 'code_rubric'),
             (r'\]', Punctuation, '#pop'),
             # handle use_archetype statement
-            (r'\s*,\s*', Punctuation),
+            (r'(\s*)(,)(\s*)', bygroups(Whitespace, Punctuation, Whitespace)),
         ],
         'code_rubric': [
             (r'\|', Punctuation, '#pop'),
@@ -153,8 +154,8 @@ class OdinLexer(AtomsLexer):
             (r'[a-z_]\w*', Name.Class),
             (r'/', Punctuation),
             (r'\[', Punctuation, 'key'),
-            (r'\s*,\s*', Punctuation, '#pop'),
-            (r'\s+', Text, '#pop'),
+            (r'(\s*)(,)(\s*)', bygroups(Whitespace, Punctuation, Whitespace), '#pop'),
+            (r'\s+', Whitespace, '#pop'),
         ],
         'key': [
             include('values'),
@@ -216,11 +217,11 @@ class CadlLexer(AtomsLexer):
             ('(\u2203|\u2204|\u2200|\u2227|\u2228|\u22BB|\223C)',
              Operator),
             # regex in slot or as string constraint
-            (r'(\{)(\s*/[^}]+/\s*)(\})',
-             bygroups(Punctuation, String.Regex, Punctuation)),
+            (r'(\{)(\s*)(/[^}]+/)(\s*)(\})',
+             bygroups(Punctuation, Whitespace, String.Regex, Whitespace, Punctuation)),
             # regex in slot or as string constraint
-            (r'(\{)(\s*\^[^}]+\^\s*)(\})',
-             bygroups(Punctuation, String.Regex, Punctuation)),
+            (r'(\{)(\s*)(\^[^}]+\^)(\s*)(\})',
+             bygroups(Punctuation, Whitespace, String.Regex, Whitespace, Punctuation)),
             (r'/', Punctuation, 'path'),
             # for cardinality etc
             (r'(\{)((?:\d+\.\.)?(?:\d+|\*))'
@@ -263,16 +264,17 @@ class AdlLexer(AtomsLexer):
     tokens = {
         'whitespace': [
             # blank line ends
-            (r'\s*\n', Text),
+            (r'\s*\n', Whitespace),
             # comment-only line
-            (r'^[ \t]*--.*$', Comment),
+            (r'^([ \t]*)(--.*)$', bygroups(Whitespace, Comment)),
         ],
         'odin_section': [
             # repeating the following two rules from the root state enable multi-line
             # strings that start in the first column to be dealt with
             (r'^(language|description|ontology|terminology|annotations|'
-             r'component_terminologies|revision_history)[ \t]*\n', Generic.Heading),
-            (r'^(definition)[ \t]*\n', Generic.Heading, 'cadl_section'),
+             r'component_terminologies|revision_history)([ \t]*\n)',
+             bygroups(Generic.Heading, Whitespace)),
+            (r'^(definition)([ \t]*\n)', bygroups(Generic.Heading, Whitespace), 'cadl_section'),
             (r'^([ \t]*|[ \t]+.*)\n', using(OdinLexer)),
             (r'^([^"]*")(>[ \t]*\n)', bygroups(String, Punctuation)),
             # template overlay delimiter
@@ -299,7 +301,7 @@ class AdlLexer(AtomsLexer):
             (r'\w+', Name.Class),
             (r'"', String, 'string'),
             (r'=', Operator),
-            (r'[ \t]+', Text),
+            (r'[ \t]+', Whitespace),
             default('#pop'),
         ],
         'root': [
@@ -311,7 +313,7 @@ class AdlLexer(AtomsLexer):
             (r'^(definition)[ \t]*\n', Generic.Heading, 'cadl_section'),
             (r'^(rules)[ \t]*\n', Generic.Heading, 'rules_section'),
             include('archetype_id'),
-            (r'[ \t]*\(', Punctuation, 'metadata'),
+            (r'([ \t]*)(\()', bygroups(Whitespace, Punctuation), 'metadata'),
             include('whitespace'),
         ],
     }

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

@@ -4,13 +4,13 @@
 
     Lexer for Arrow.
 
-    :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.
 """
 
 from pygments.lexer import RegexLexer, bygroups, default, include
 from pygments.token import Text, Operator, Keyword, Punctuation, Name, \
-    String, Number
+    String, Number, Whitespace
 
 __all__ = ['ArrowLexer']
 
@@ -21,18 +21,19 @@ DECL = TYPES + r'(\s+)' + IDENT
 
 class ArrowLexer(RegexLexer):
     """
-    Lexer for Arrow: https://pypi.org/project/py-arrow-lang/
+    Lexer for Arrow
 
     .. versionadded:: 2.7
     """
 
     name = 'Arrow'
+    url = 'https://pypi.org/project/py-arrow-lang/'
     aliases = ['arrow']
     filenames = ['*.arw']
 
     tokens = {
         'root': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'^[|\s]+', Punctuation),
             include('blocks'),
             include('statements'),
@@ -42,8 +43,8 @@ class ArrowLexer(RegexLexer):
             (r'(function)(\n+)(/-->)(\s*)' +
              DECL +  # 4 groups
              r'(\()', bygroups(
-                 Keyword.Reserved, Text, Punctuation,
-                 Text, Keyword.Type, Punctuation, Text,
+                 Keyword.Reserved, Whitespace, Punctuation,
+                 Whitespace, Keyword.Type, Punctuation, Whitespace,
                  Name.Function, Punctuation
              ), 'fparams'),
             (r'/-->$|\\-->$|/--<|\\--<|\^', Punctuation),
@@ -56,7 +57,7 @@ class ArrowLexer(RegexLexer):
             (r'print', Keyword.Reserved, 'print'),
         ],
         'expressions': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'[0-9]+', Number.Integer),
             (r'true|false', Keyword.Constant),
             (r"'", String.Char, 'char'),
@@ -65,7 +66,7 @@ class ArrowLexer(RegexLexer):
             (r'==|!=|<|>|\+|-|\*|/|%', Operator),
             (r'and|or|not|length', Operator.Word),
             (r'(input)(\s+)(int|char\[\])', bygroups(
-                Keyword.Reserved, Text, Keyword.Type
+                Keyword.Reserved, Whitespace, Keyword.Type
             )),
             (IDENT + r'(\()', bygroups(
                 Name.Function, Punctuation
@@ -81,7 +82,7 @@ class ArrowLexer(RegexLexer):
             default('#pop'),
         ],
         'fparams': [
-            (DECL, bygroups(Keyword.Type, Punctuation, Text, Name.Variable)),
+            (DECL, bygroups(Keyword.Type, Punctuation, Whitespace, Name.Variable)),
             (r',', Punctuation),
             (r'\)', Punctuation, '#pop'),
         ],