pygments.rb 2.4.1 → 4.0.0

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

@@ -4,7 +4,7 @@
 
     Lexers for ML family languages.
 
-    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -20,14 +20,14 @@ __all__ = ['SMLLexer', 'OcamlLexer', 'OpaLexer', 'ReasonLexer', 'FStarLexer']
 class SMLLexer(RegexLexer):
     """
     For the Standard ML language.
-
-    .. versionadded:: 1.5
     """
 
     name = 'Standard ML'
     aliases = ['sml']
     filenames = ['*.sml', '*.sig', '*.fun']
     mimetypes = ['text/x-standardml', 'application/x-standardml']
+    url = 'https://en.wikipedia.org/wiki/Standard_ML'
+    version_added = '1.5'
 
     alphanumid_reserved = {
         # Core
@@ -121,7 +121,7 @@ class SMLLexer(RegexLexer):
 
         'core': [
             # Punctuation that doesn't overlap symbolic identifiers
-            (r'(%s)' % '|'.join(re.escape(z) for z in nonid_reserved),
+            (r'({})'.format('|'.join(re.escape(z) for z in nonid_reserved)),
              Punctuation),
 
             # Special constants: strings, floats, numbers in decimal and hex
@@ -137,8 +137,8 @@ class SMLLexer(RegexLexer):
 
             # Labels
             (r'#\s*[1-9][0-9]*', Name.Label),
-            (r'#\s*(%s)' % alphanumid_re, Name.Label),
-            (r'#\s+(%s)' % symbolicid_re, Name.Label),
+            (rf'#\s*({alphanumid_re})', Name.Label),
+            (rf'#\s+({symbolicid_re})', Name.Label),
             # Some reserved words trigger a special, local lexer state change
             (r'\b(datatype|abstype)\b(?!\')', Keyword.Reserved, 'dname'),
             (r'\b(exception)\b(?!\')', Keyword.Reserved, 'ename'),
@@ -148,14 +148,14 @@ class SMLLexer(RegexLexer):
 
             # Regular identifiers, long and otherwise
             (r'\'[\w\']*', Name.Decorator),
-            (r'(%s)(\.)' % alphanumid_re, long_id_callback, "dotted"),
-            (r'(%s)' % alphanumid_re, id_callback),
-            (r'(%s)' % symbolicid_re, id_callback),
+            (rf'({alphanumid_re})(\.)', long_id_callback, "dotted"),
+            (rf'({alphanumid_re})', id_callback),
+            (rf'({symbolicid_re})', id_callback),
         ],
         'dotted': [
-            (r'(%s)(\.)' % alphanumid_re, long_id_callback),
-            (r'(%s)' % alphanumid_re, end_id_callback, "#pop"),
-            (r'(%s)' % symbolicid_re, end_id_callback, "#pop"),
+            (rf'({alphanumid_re})(\.)', long_id_callback),
+            (rf'({alphanumid_re})', end_id_callback, "#pop"),
+            (rf'({symbolicid_re})', end_id_callback, "#pop"),
             (r'\s+', Error),
             (r'\S+', Error),
         ],
@@ -208,7 +208,7 @@ class SMLLexer(RegexLexer):
         'string': stringy(String.Double),
 
         'breakout': [
-            (r'(?=\b(%s)\b(?!\'))' % '|'.join(alphanumid_reserved), Text, '#pop'),
+            (r'(?=\b({})\b(?!\'))'.format('|'.join(alphanumid_reserved)), Text, '#pop'),
         ],
 
         # Dealing with what comes after module system keywords
@@ -216,7 +216,7 @@ class SMLLexer(RegexLexer):
             include('whitespace'),
             include('breakout'),
 
-            (r'(%s)' % alphanumid_re, Name.Namespace),
+            (rf'({alphanumid_re})', Name.Namespace),
             default('#pop'),
         ],
 
@@ -226,8 +226,8 @@ class SMLLexer(RegexLexer):
             (r'\'[\w\']*', Name.Decorator),
             (r'\(', Punctuation, 'tyvarseq'),
 
-            (r'(%s)' % alphanumid_re, Name.Function, '#pop'),
-            (r'(%s)' % symbolicid_re, Name.Function, '#pop'),
+            (rf'({alphanumid_re})', Name.Function, '#pop'),
+            (rf'({symbolicid_re})', Name.Function, '#pop'),
 
             # Ignore interesting function declarations like "fun (x + y) = ..."
             default('#pop'),
@@ -239,12 +239,12 @@ class SMLLexer(RegexLexer):
             (r'\'[\w\']*', Name.Decorator),
             (r'\(', Punctuation, 'tyvarseq'),
 
-            (r'(%s)(\s*)(=(?!%s))' % (alphanumid_re, symbolicid_re),
+            (rf'({alphanumid_re})(\s*)(=(?!{symbolicid_re}))',
              bygroups(Name.Variable, Text, Punctuation), '#pop'),
-            (r'(%s)(\s*)(=(?!%s))' % (symbolicid_re, symbolicid_re),
+            (rf'({symbolicid_re})(\s*)(=(?!{symbolicid_re}))',
              bygroups(Name.Variable, Text, Punctuation), '#pop'),
-            (r'(%s)' % alphanumid_re, Name.Variable, '#pop'),
-            (r'(%s)' % symbolicid_re, Name.Variable, '#pop'),
+            (rf'({alphanumid_re})', Name.Variable, '#pop'),
+            (rf'({symbolicid_re})', Name.Variable, '#pop'),
 
             # Ignore interesting patterns like 'val (x, y)'
             default('#pop'),
@@ -257,10 +257,10 @@ class SMLLexer(RegexLexer):
 
             (r'\'[\w\']*', Name.Decorator),
             (r'\(', Punctuation, 'tyvarseq'),
-            (r'=(?!%s)' % symbolicid_re, Punctuation, ('#pop', 'typbind')),
+            (rf'=(?!{symbolicid_re})', Punctuation, ('#pop', 'typbind')),
 
-            (r'(%s)' % alphanumid_re, Keyword.Type),
-            (r'(%s)' % symbolicid_re, Keyword.Type),
+            (rf'({alphanumid_re})', Keyword.Type),
+            (rf'({symbolicid_re})', Keyword.Type),
             (r'\S+', Error, '#pop'),
         ],
 
@@ -284,11 +284,11 @@ class SMLLexer(RegexLexer):
             (r'\(', Punctuation, 'tyvarseq'),
             (r'(=)(\s*)(datatype)',
              bygroups(Punctuation, Text, Keyword.Reserved), '#pop'),
-            (r'=(?!%s)' % symbolicid_re, Punctuation,
+            (rf'=(?!{symbolicid_re})', Punctuation,
              ('#pop', 'datbind', 'datcon')),
 
-            (r'(%s)' % alphanumid_re, Keyword.Type),
-            (r'(%s)' % symbolicid_re, Keyword.Type),
+            (rf'({alphanumid_re})', Keyword.Type),
+            (rf'({symbolicid_re})', Keyword.Type),
             (r'\S+', Error, '#pop'),
         ],
 
@@ -300,9 +300,9 @@ class SMLLexer(RegexLexer):
             (r'\b(withtype)\b(?!\')', Keyword.Reserved, ('#pop', 'tname')),
             (r'\b(of)\b(?!\')', Keyword.Reserved),
 
-            (r'(\|)(\s*)(%s)' % alphanumid_re,
+            (rf'(\|)(\s*)({alphanumid_re})',
              bygroups(Punctuation, Text, Name.Class)),
-            (r'(\|)(\s+)(%s)' % symbolicid_re,
+            (rf'(\|)(\s+)({symbolicid_re})',
              bygroups(Punctuation, Text, Name.Class)),
 
             include('breakout'),
@@ -314,20 +314,20 @@ class SMLLexer(RegexLexer):
         'ename': [
             include('whitespace'),
 
-            (r'(and\b)(\s+)(%s)' % alphanumid_re,
+            (rf'(and\b)(\s+)({alphanumid_re})',
              bygroups(Keyword.Reserved, Text, Name.Class)),
-            (r'(and\b)(\s*)(%s)' % symbolicid_re,
+            (rf'(and\b)(\s*)({symbolicid_re})',
              bygroups(Keyword.Reserved, Text, Name.Class)),
             (r'\b(of)\b(?!\')', Keyword.Reserved),
-            (r'(%s)|(%s)' % (alphanumid_re, symbolicid_re), Name.Class),
+            (rf'({alphanumid_re})|({symbolicid_re})', Name.Class),
 
             default('#pop'),
         ],
 
         'datcon': [
             include('whitespace'),
-            (r'(%s)' % alphanumid_re, Name.Class, '#pop'),
-            (r'(%s)' % symbolicid_re, Name.Class, '#pop'),
+            (rf'({alphanumid_re})', Name.Class, '#pop'),
+            (rf'({symbolicid_re})', Name.Class, '#pop'),
             (r'\S+', Error, '#pop'),
         ],
 
@@ -355,8 +355,6 @@ class SMLLexer(RegexLexer):
 class OcamlLexer(RegexLexer):
     """
     For the OCaml language.
-
-    .. versionadded:: 0.7
     """
 
     name = 'OCaml'
@@ -364,15 +362,16 @@ class OcamlLexer(RegexLexer):
     aliases = ['ocaml']
     filenames = ['*.ml', '*.mli', '*.mll', '*.mly']
     mimetypes = ['text/x-ocaml']
+    version_added = '0.7'
 
     keywords = (
-        'as', 'assert', 'begin', 'class', 'constraint', 'do', 'done',
+        'and', 'as', 'assert', 'begin', 'class', 'constraint', 'do', 'done',
         'downto', 'else', 'end', 'exception', 'external', 'false',
         'for', 'fun', 'function', 'functor', 'if', 'in', 'include',
         'inherit', 'initializer', 'lazy', 'let', 'match', 'method',
         'module', 'mutable', 'new', 'object', 'of', 'open', 'private',
         'raise', 'rec', 'sig', 'struct', 'then', 'to', 'true', 'try',
-        'type', 'value', 'val', 'virtual', 'when', 'while', 'with',
+        'type', 'val', 'virtual', 'when', 'while', 'with',
     )
     keyopts = (
         '!=', '#', '&', '&&', r'\(', r'\)', r'\*', r'\+', ',', '-',
@@ -382,7 +381,7 @@ class OcamlLexer(RegexLexer):
     )
 
     operators = r'[!$%&*+\./:<=>?@^|~-]'
-    word_operators = ('and', 'asr', 'land', 'lor', 'lsl', 'lxor', 'mod', 'or')
+    word_operators = ('asr', 'land', 'lor', 'lsl', 'lxor', 'mod', 'or')
     prefix_syms = r'[!?~]'
     infix_syms = r'[=<>@^|&+\*/$%-]'
     primitives = ('unit', 'int', 'float', 'bool', 'string', 'char', 'list', 'array')
@@ -399,11 +398,11 @@ class OcamlLexer(RegexLexer):
             (r'\b([A-Z][\w\']*)(?=\s*\.)', Name.Namespace, 'dotted'),
             (r'\b([A-Z][\w\']*)', Name.Class),
             (r'\(\*(?![)])', Comment, 'comment'),
-            (r'\b(%s)\b' % '|'.join(keywords), Keyword),
-            (r'(%s)' % '|'.join(keyopts[::-1]), Operator),
-            (r'(%s|%s)?%s' % (infix_syms, prefix_syms, operators), Operator),
-            (r'\b(%s)\b' % '|'.join(word_operators), Operator.Word),
-            (r'\b(%s)\b' % '|'.join(primitives), Keyword.Type),
+            (r'\b({})\b'.format('|'.join(keywords)), Keyword),
+            (r'({})'.format('|'.join(keyopts[::-1])), Operator),
+            (rf'({infix_syms}|{prefix_syms})?{operators}', Operator),
+            (r'\b({})\b'.format('|'.join(word_operators)), Operator.Word),
+            (r'\b({})\b'.format('|'.join(primitives)), Keyword.Type),
 
             (r"[^\W\d][\w']*", Name),
 
@@ -448,14 +447,14 @@ class OcamlLexer(RegexLexer):
 class OpaLexer(RegexLexer):
     """
     Lexer for the Opa language.
-
-    .. versionadded:: 1.5
     """
 
     name = 'Opa'
     aliases = ['opa']
     filenames = ['*.opa']
     mimetypes = ['text/x-opa']
+    url = 'http://opalang.org'
+    version_added = '1.5'
 
     # most of these aren't strictly keywords
     # but if you color only real keywords, you might just
@@ -557,8 +556,8 @@ class OpaLexer(RegexLexer):
             # way to syntactic distinguish binding constructions
             # unfortunately, this colors the equal in {x=2} too
             (r'=(?!'+op_re+r')', Keyword),
-            (r'(%s)+' % op_re, Operator),
-            (r'(%s)+' % punc_re, Operator),
+            (rf'({op_re})+', Operator),
+            (rf'({punc_re})+', Operator),
 
             # coercions
             (r':', Operator, 'type'),
@@ -771,8 +770,6 @@ class OpaLexer(RegexLexer):
 class ReasonLexer(RegexLexer):
     """
     For the ReasonML language.
-
-    .. versionadded:: 2.6
     """
 
     name = 'ReasonML'
@@ -780,6 +777,7 @@ class ReasonLexer(RegexLexer):
     aliases = ['reasonml', 'reason']
     filenames = ['*.re', '*.rei']
     mimetypes = ['text/x-reasonml']
+    version_added = '2.6'
 
     keywords = (
         'as', 'assert', 'begin', 'class', 'constraint', 'do', 'done', 'downto',
@@ -815,11 +813,11 @@ class ReasonLexer(RegexLexer):
             (r'\b([A-Z][\w\']*)', Name.Class),
             (r'//.*?\n', Comment.Single),
             (r'\/\*(?!/)', Comment.Multiline, 'comment'),
-            (r'\b(%s)\b' % '|'.join(keywords), Keyword),
-            (r'(%s)' % '|'.join(keyopts[::-1]), Operator.Word),
-            (r'(%s|%s)?%s' % (infix_syms, prefix_syms, operators), Operator),
-            (r'\b(%s)\b' % '|'.join(word_operators), Operator.Word),
-            (r'\b(%s)\b' % '|'.join(primitives), Keyword.Type),
+            (r'\b({})\b'.format('|'.join(keywords)), Keyword),
+            (r'({})'.format('|'.join(keyopts[::-1])), Operator.Word),
+            (rf'({infix_syms}|{prefix_syms})?{operators}', Operator),
+            (r'\b({})\b'.format('|'.join(word_operators)), Operator.Word),
+            (r'\b({})\b'.format('|'.join(primitives)), Keyword.Type),
 
             (r"[^\W\d][\w']*", Name),
 
@@ -864,7 +862,6 @@ class ReasonLexer(RegexLexer):
 class FStarLexer(RegexLexer):
     """
     For the F* language.
-    .. versionadded:: 2.7
     """
 
     name = 'FStar'
@@ -872,6 +869,7 @@ class FStarLexer(RegexLexer):
     aliases = ['fstar']
     filenames = ['*.fst', '*.fsti']
     mimetypes = ['text/x-fstar']
+    version_added = '2.7'
 
     keywords = (
         'abstract', 'attributes', 'noeq', 'unopteq', 'and'
@@ -912,12 +910,12 @@ class FStarLexer(RegexLexer):
             (r'\b([A-Z][\w\']*)', Name.Class),
             (r'\(\*(?![)])', Comment, 'comment'),
             (r'\/\/.+$', Comment),
-            (r'\b(%s)\b' % '|'.join(keywords), Keyword),
-            (r'\b(%s)\b' % '|'.join(assume_keywords), Name.Exception),
-            (r'\b(%s)\b' % '|'.join(decl_keywords), Keyword.Declaration),
-            (r'(%s)' % '|'.join(keyopts[::-1]), Operator),
-            (r'(%s|%s)?%s' % (infix_syms, prefix_syms, operators), Operator),
-            (r'\b(%s)\b' % '|'.join(primitives), Keyword.Type),
+            (r'\b({})\b'.format('|'.join(keywords)), Keyword),
+            (r'\b({})\b'.format('|'.join(assume_keywords)), Name.Exception),
+            (r'\b({})\b'.format('|'.join(decl_keywords)), Keyword.Declaration),
+            (r'({})'.format('|'.join(keyopts[::-1])), Operator),
+            (rf'({infix_syms}|{prefix_syms})?{operators}', Operator),
+            (r'\b({})\b'.format('|'.join(primitives)), Keyword.Type),
 
             (r"[^\W\d][\w']*", Name),
 

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

@@ -4,7 +4,7 @@
 
     Lexers for modeling languages.
 
-    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -23,14 +23,13 @@ __all__ = ['ModelicaLexer', 'BugsLexer', 'JagsLexer', 'StanLexer']
 class ModelicaLexer(RegexLexer):
     """
     For Modelica source code.
-
-    .. versionadded:: 1.1
     """
     name = 'Modelica'
     url = 'http://www.modelica.org/'
     aliases = ['modelica']
     filenames = ['*.mo']
     mimetypes = ['text/x-modelica']
+    version_added = '1.1'
 
     flags = re.DOTALL | re.MULTILINE
 
@@ -100,13 +99,13 @@ class BugsLexer(RegexLexer):
     """
     Pygments Lexer for OpenBugs and WinBugs
     models.
-
-    .. versionadded:: 1.6
     """
 
     name = 'BUGS'
     aliases = ['bugs', 'winbugs', 'openbugs']
     filenames = ['*.bug']
+    url = 'https://www.mrc-bsu.cam.ac.uk/software/bugs/openbugs'
+    version_added = '1.6'
 
     _FUNCTIONS = (
         # Scalar functions
@@ -166,8 +165,7 @@ class BugsLexer(RegexLexer):
             # Reserved Words
             (r'(for|in)(?![\w.])', Keyword.Reserved),
             # Built-in Functions
-            (r'(%s)(?=\s*\()'
-             % r'|'.join(_FUNCTIONS + _DISTRIBUTIONS),
+            (r'({})(?=\s*\()'.format(r'|'.join(_FUNCTIONS + _DISTRIBUTIONS)),
              Name.Builtin),
             # Regular variable names
             (r'[A-Za-z][\w.]*', Name),
@@ -195,13 +193,13 @@ class BugsLexer(RegexLexer):
 class JagsLexer(RegexLexer):
     """
     Pygments Lexer for JAGS.
-
-    .. versionadded:: 1.6
     """
 
     name = 'JAGS'
     aliases = ['jags']
     filenames = ['*.jag', '*.bug']
+    url = 'https://mcmc-jags.sourceforge.io'
+    version_added = '1.6'
 
     # JAGS
     _FUNCTIONS = (
@@ -215,7 +213,7 @@ class JagsLexer(RegexLexer):
         # Truncation/Censoring (should I include)
         'T', 'I')
     # Distributions with density, probability and quartile functions
-    _DISTRIBUTIONS = tuple('[dpq]%s' % x for x in
+    _DISTRIBUTIONS = tuple(f'[dpq]{x}' for x in
                            ('bern', 'beta', 'dchiqsqr', 'ddexp', 'dexp',
                             'df', 'gamma', 'gen.gamma', 'logis', 'lnorm',
                             'negbin', 'nchisqr', 'norm', 'par', 'pois', 'weib'))
@@ -251,9 +249,9 @@ class JagsLexer(RegexLexer):
             (r'(for|in)(?![\w.])', Keyword.Reserved),
             # Builtins
             # Need to use lookahead because . is a valid char
-            (r'(%s)(?=\s*\()' % r'|'.join(_FUNCTIONS
+            (r'({})(?=\s*\()'.format(r'|'.join(_FUNCTIONS
                                           + _DISTRIBUTIONS
-                                          + _OTHER_DISTRIBUTIONS),
+                                          + _OTHER_DISTRIBUTIONS)),
              Name.Builtin),
             # Names
             include('names'),
@@ -286,13 +284,13 @@ class StanLexer(RegexLexer):
     The Stan modeling language is specified in the *Stan Modeling Language
     User's Guide and Reference Manual, v2.17.0*,
     `pdf <https://github.com/stan-dev/stan/releases/download/v2.17.0/stan-reference-2.17.0.pdf>`__.
-
-    .. versionadded:: 1.6
     """
 
     name = 'Stan'
     aliases = ['stan']
     filenames = ['*.stan']
+    url = 'https://mc-stan.org'
+    version_added = '1.6'
 
     tokens = {
         'whitespace': [
@@ -310,19 +308,18 @@ class StanLexer(RegexLexer):
             # block start
             include('whitespace'),
             # Block start
-            (r'(%s)(\s*)(\{)' %
-             r'|'.join(('functions', 'data', r'transformed\s+?data',
+            (r'({})(\s*)(\{{)'.format(r'|'.join(('functions', 'data', r'transformed\s+?data',
                         'parameters', r'transformed\s+parameters',
-                        'model', r'generated\s+quantities')),
+                        'model', r'generated\s+quantities'))),
              bygroups(Keyword.Namespace, Text, Punctuation)),
             # target keyword
             (r'target\s*\+=', Keyword),
             # Reserved Words
-            (r'(%s)\b' % r'|'.join(_stan_builtins.KEYWORDS), Keyword),
+            (r'({})\b'.format(r'|'.join(_stan_builtins.KEYWORDS)), Keyword),
             # Truncation
             (r'T(?=\s*\[)', Keyword),
             # Data types
-            (r'(%s)\b' % r'|'.join(_stan_builtins.TYPES), Keyword.Type),
+            (r'({})\b'.format(r'|'.join(_stan_builtins.TYPES)), Keyword.Type),
              # < should be punctuation, but elsewhere I can't tell if it is in
              # a range constraint
             (r'(<)(\s*)(upper|lower|offset|multiplier)(\s*)(=)',
@@ -332,12 +329,12 @@ class StanLexer(RegexLexer):
             # Punctuation
             (r"[;,\[\]()]", Punctuation),
             # Builtin
-            (r'(%s)(?=\s*\()' % '|'.join(_stan_builtins.FUNCTIONS), Name.Builtin),
-            (r'(~)(\s*)(%s)(?=\s*\()' % '|'.join(_stan_builtins.DISTRIBUTIONS),
+            (r'({})(?=\s*\()'.format('|'.join(_stan_builtins.FUNCTIONS)), Name.Builtin),
+            (r'(~)(\s*)({})(?=\s*\()'.format('|'.join(_stan_builtins.DISTRIBUTIONS)),
                 bygroups(Operator, Whitespace, Name.Builtin)),
             # Special names ending in __, like lp__
             (r'[A-Za-z]\w*__\b', Name.Builtin.Pseudo),
-            (r'(%s)\b' % r'|'.join(_stan_builtins.RESERVED), Keyword.Reserved),
+            (r'({})\b'.format(r'|'.join(_stan_builtins.RESERVED)), Keyword.Reserved),
             # user-defined functions
             (r'[A-Za-z]\w*(?=\s*\()]', Name.Function),
             # Imaginary Literals

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

@@ -4,7 +4,7 @@
 
     Multi-Dialect Lexer for Modula-2.
 
-    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2025 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -153,8 +153,6 @@ class Modula2Lexer(RegexLexer):
     ``$ pygmentize -O full,dialect=m2r10,treat_stdlib_adts_as_builtins=Off ...``
         Render standard library ADTs as ordinary library types.
 
-    .. versionadded:: 1.3
-
     .. versionchanged:: 2.1
        Added multi-dialect support.
     """
@@ -163,6 +161,7 @@ class Modula2Lexer(RegexLexer):
     aliases = ['modula2', 'm2']
     filenames = ['*.def', '*.mod']
     mimetypes = ['text/x-modula2']
+    version_added = '1.3'
 
     flags = re.MULTILINE | re.DOTALL