pygments.rb 2.3.1 → 2.4.0

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

@@ -4,13 +4,13 @@
 
     Lexers for misc console output.
 
-    :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
 from pygments.token import Generic, Comment, String, Text, Keyword, Name, \
-    Punctuation, Number
+    Punctuation, Number, Whitespace
 
 __all__ = ['VCTreeStatusLexer', 'PyPyLogLexer']
 
@@ -36,7 +36,8 @@ class VCTreeStatusLexer(RegexLexer):
             (r'^D\s+', Generic.Deleted),
             (r'^[?!]\s+', Comment.Preproc),
             (r'      >\s+.*\n', Comment.Preproc),
-            (r'.*\n', Text)
+            (r'\S+', Text),
+            (r'\s+', Whitespace),
         ]
     }
 
@@ -107,7 +108,7 @@ class PyPyLogLexer(RegexLexer):
             include("extra-stuff"),
         ],
         "extra-stuff": [
-            (r"\s+", Text),
+            (r"\s+", Whitespace),
             (r"#.*?$", Comment),
         ],
     }

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

@@ -0,0 +1,44 @@
+"""
+    pygments.lexers.cplint
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for the cplint language
+
+    :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import bygroups, inherit, words
+from pygments.lexers import PrologLexer
+from pygments.token import Operator, Keyword, Name, String, Punctuation
+
+__all__ = ['CplintLexer']
+
+
+class CplintLexer(PrologLexer):
+    """
+    Lexer for cplint files, including CP-logic, Logic Programs with Annotated
+    Disjunctions, Distributional Clauses syntax, ProbLog, DTProbLog.
+
+    .. versionadded:: 2.12
+    """
+    name = 'cplint'
+    url = 'https://cplint.eu'
+    aliases = ['cplint']
+    filenames = ['*.ecl', '*.prolog', '*.pro', '*.pl', '*.P', '*.lpad', '*.cpl']
+    mimetypes = ['text/x-cplint']
+
+    tokens = {
+        'root': [
+            (r'map_query', Keyword),
+            (words(('gaussian', 'uniform_dens', 'dirichlet', 'gamma', 'beta',
+                    'poisson', 'binomial', 'geometric', 'exponential', 'pascal',
+                    'multinomial', 'user', 'val', 'uniform', 'discrete',
+                    'finite')), Name.Builtin),
+            # annotations of atoms
+            (r'([a-z]+)(:)', bygroups(String.Atom, Punctuation)),
+            (r':(-|=)|::?|~=?|=>', Operator),
+            (r'\?', Name.Builtin),
+            inherit,
+        ],
+    }

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

@@ -4,21 +4,19 @@
 
     Lexer for Crystal.
 
-    :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 ExtendedRegexLexer, include, \
-    bygroups, default, LexerContext, words
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Error
+from pygments.lexer import ExtendedRegexLexer, include, bygroups, default, \
+    words, line_re
+from pygments.token import Comment, Operator, Keyword, Name, String, Number, \
+    Punctuation, Error, Whitespace
 
 __all__ = ['CrystalLexer']
 
-line_re = re.compile('.*?\n')
-
 
 CRYSTAL_OPERATORS = [
     '!=', '!~', '!', '%', '&&', '&', '**', '*', '+', '-', '/', '<=>', '<<', '<=', '<',
@@ -28,12 +26,13 @@ CRYSTAL_OPERATORS = [
 
 class CrystalLexer(ExtendedRegexLexer):
     """
-    For `Crystal <http://crystal-lang.org>`_ source code.
+    For Crystal source code.
 
     .. versionadded:: 2.2
     """
 
     name = 'Crystal'
+    url = 'http://crystal-lang.org'
     aliases = ['cr', 'crystal']
     filenames = ['*.cr']
     mimetypes = ['text/x-crystal']
@@ -177,12 +176,12 @@ class CrystalLexer(ExtendedRegexLexer):
             (words(['true', 'false', 'nil'], suffix=r'\b'), Keyword.Constant),
             # start of function, class and module names
             (r'(module|lib)(\s+)([a-zA-Z_]\w*(?:::[a-zA-Z_]\w*)*)',
-             bygroups(Keyword, Text, Name.Namespace)),
+             bygroups(Keyword, Whitespace, Name.Namespace)),
             (r'(def|fun|macro)(\s+)((?:[a-zA-Z_]\w*::)*)',
-             bygroups(Keyword, Text, Name.Namespace), 'funcname'),
+             bygroups(Keyword, Whitespace, Name.Namespace), 'funcname'),
             (r'def(?=[*%&^`~+-/\[<>=])', Keyword, 'funcname'),
             (r'(annotation|class|struct|union|type|alias|enum)(\s+)((?:[a-zA-Z_]\w*::)*)',
-             bygroups(Keyword, Text, Name.Namespace), 'classname'),
+             bygroups(Keyword, Whitespace, Name.Namespace), 'classname'),
             # https://crystal-lang.org/api/toplevel.html
             (words('''
                 instance_sizeof offsetof pointerof sizeof typeof
@@ -228,11 +227,11 @@ class CrystalLexer(ExtendedRegexLexer):
              r'(?<=^match\s)|'
              r'(?<=^if\s)|'
              r'(?<=^elsif\s)'
-             r')(\s*)(/)', bygroups(Text, String.Regex), 'multiline-regex'),
+             r')(\s*)(/)', bygroups(Whitespace, String.Regex), 'multiline-regex'),
             # multiline regex (in method calls or subscripts)
             (r'(?<=\(|,|\[)/', String.Regex, 'multiline-regex'),
             # multiline regex (this time the funny no whitespace rule)
-            (r'(\s+)(/)(?![\s=])', bygroups(Text, String.Regex),
+            (r'(\s+)(/)(?![\s=])', bygroups(Whitespace, String.Regex),
              'multiline-regex'),
             # lex numbers and ignore following regular expressions which
             # are division operators in fact (grrrr. i hate that. any
@@ -243,24 +242,24 @@ class CrystalLexer(ExtendedRegexLexer):
             # stupid example:
             #   x>=0?n[x]:""
             (r'(0o[0-7]+(?:_[0-7]+)*(?:_?[iu][0-9]+)?)\b(\s*)([/?])?',
-             bygroups(Number.Oct, Text, Operator)),
+             bygroups(Number.Oct, Whitespace, Operator)),
             (r'(0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*(?:_?[iu][0-9]+)?)\b(\s*)([/?])?',
-             bygroups(Number.Hex, Text, Operator)),
+             bygroups(Number.Hex, Whitespace, Operator)),
             (r'(0b[01]+(?:_[01]+)*(?:_?[iu][0-9]+)?)\b(\s*)([/?])?',
-             bygroups(Number.Bin, Text, Operator)),
+             bygroups(Number.Bin, Whitespace, Operator)),
             # 3 separate expressions for floats because any of the 3 optional
             # parts makes it a float
             (r'((?:0(?![0-9])|[1-9][\d_]*)(?:\.\d[\d_]*)(?:e[+-]?[0-9]+)?'
              r'(?:_?f[0-9]+)?)(\s*)([/?])?',
-             bygroups(Number.Float, Text, Operator)),
+             bygroups(Number.Float, Whitespace, Operator)),
             (r'((?:0(?![0-9])|[1-9][\d_]*)(?:\.\d[\d_]*)?(?:e[+-]?[0-9]+)'
              r'(?:_?f[0-9]+)?)(\s*)([/?])?',
-             bygroups(Number.Float, Text, Operator)),
+             bygroups(Number.Float, Whitespace, Operator)),
             (r'((?:0(?![0-9])|[1-9][\d_]*)(?:\.\d[\d_]*)?(?:e[+-]?[0-9]+)?'
              r'(?:_?f[0-9]+))(\s*)([/?])?',
-             bygroups(Number.Float, Text, Operator)),
+             bygroups(Number.Float, Whitespace, Operator)),
             (r'(0\b|[1-9][\d]*(?:_\d+)*(?:_?[iu][0-9]+)?)\b(\s*)([/?])?',
-             bygroups(Number.Integer, Text, Operator)),
+             bygroups(Number.Integer, Whitespace, Operator)),
             # Names
             (r'@@[a-zA-Z_]\w*', Name.Variable.Class),
             (r'@[a-zA-Z_]\w*', Name.Variable.Instance),
@@ -280,7 +279,7 @@ class CrystalLexer(ExtendedRegexLexer):
             (r'\{\{', String.Interpol, 'in-macro-expr'),
             # annotations
             (r'(@\[)(\s*)([A-Z]\w*(::[A-Z]\w*)*)',
-             bygroups(Operator, Text, Name.Decorator), 'in-annot'),
+             bygroups(Operator, Whitespace, Name.Decorator), 'in-annot'),
             # this is needed because Crystal attributes can look
             # like keywords (class) or like this: ` ?!?
             (words(CRYSTAL_OPERATORS, prefix=r'(\.|::)'),
@@ -293,7 +292,7 @@ class CrystalLexer(ExtendedRegexLexer):
              r'!~|&&?|\|\||\.{1,3})', Operator),
             (r'[-+/*%=<>&!^|~]=?', Operator),
             (r'[(){};,/?:\\]', Punctuation),
-            (r'\s+', Text)
+            (r'\s+', Whitespace)
         ],
         'funcname': [
             (r'(?:([a-zA-Z_]\w*)(\.))?'
@@ -305,7 +304,7 @@ class CrystalLexer(ExtendedRegexLexer):
         'classname': [
             (r'[A-Z_]\w*', Name.Class),
             (r'(\()(\s*)([A-Z_]\w*)(\s*)(\))',
-             bygroups(Punctuation, Text, Name.Class, Text, Punctuation)),
+             bygroups(Punctuation, Whitespace, Name.Class, Whitespace, Punctuation)),
             default('#pop')
         ],
         'in-intp': [

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

@@ -4,7 +4,7 @@
 
     Lexers for Csound languages.
 
-    :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.
 """
 
@@ -24,12 +24,14 @@ newline = (r'((?:(?:;|//).*)*)(\n)', bygroups(Comment.Single, Text))
 
 
 class CsoundLexer(RegexLexer):
+    url = 'https://csound.com/'
+
     tokens = {
         'whitespace': [
-            (r'[ \t]+', Text),
+            (r'[ \t]+', Whitespace),
             (r'/[*](?:.|\n)*?[*]/', Comment.Multiline),
             (r'(?:;|//).*$', Comment.Single),
-            (r'(\\)(\n)', bygroups(Whitespace, Text))
+            (r'(\\)(\n)', bygroups(Text, Whitespace))
         ],
 
         'preprocessor directives': [
@@ -50,7 +52,7 @@ class CsoundLexer(RegexLexer):
         ],
 
         'define directive': [
-            (r'\n', Text),
+            (r'\n', Whitespace),
             include('whitespace'),
             (r'([A-Z_a-z]\w*)(\()', bygroups(Comment.Preproc, Punctuation),
              ('#pop', 'macro parameter name list')),
@@ -63,7 +65,7 @@ class CsoundLexer(RegexLexer):
             (r'\)', Punctuation, ('#pop', 'before macro body'))
         ],
         'before macro body': [
-            (r'\n', Text),
+            (r'\n', Whitespace),
             include('whitespace'),
             (r'#', Punctuation, ('#pop', 'macro body'))
         ],
@@ -144,7 +146,7 @@ class CsoundScoreLexer(CsoundLexer):
 
     tokens = {
         'root': [
-            (r'\n', Text),
+            (r'\n', Whitespace),
             include('whitespace and macro uses'),
             include('preprocessor directives'),
 
@@ -172,7 +174,7 @@ class CsoundScoreLexer(CsoundLexer):
         'mark statement': [
             include('whitespace and macro uses'),
             (r'[A-Z_a-z]\w*', Name.Label),
-            (r'\n', Text, '#pop')
+            (r'\n', Whitespace, '#pop')
         ],
 
         'loop after left brace': [
@@ -238,9 +240,9 @@ class CsoundOrchestraLexer(CsoundLexer):
 
     tokens = {
         'root': [
-            (r'\n', Text),
+            (r'\n', Whitespace),
 
-            (r'^([ \t]*)(\w+)(:)([ \t]+|$)', bygroups(Text, Name.Label, Punctuation, Text)),
+            (r'^([ \t]*)(\w+)(:)([ \t]+|$)', bygroups(Whitespace, Name.Label, Punctuation, Whitespace)),
 
             include('whitespace and macro uses'),
             include('preprocessor directives'),
@@ -291,13 +293,13 @@ class CsoundOrchestraLexer(CsoundLexer):
             include('whitespace and macro uses'),
             (r'\d+|[A-Z_a-z]\w*', Name.Function),
             (r'[+,]', Punctuation),
-            (r'\n', Text, '#pop')
+            (r'\n', Whitespace, '#pop')
         ],
 
         'after opcode keyword': [
             include('whitespace and macro uses'),
             (r'[A-Z_a-z]\w*', opcode_name_callback, ('#pop', 'opcode type signatures')),
-            (r'\n', Text, '#pop')
+            (r'\n', Whitespace, '#pop')
         ],
         'opcode type signatures': [
             include('whitespace and macro uses'),
@@ -306,7 +308,7 @@ class CsoundOrchestraLexer(CsoundLexer):
             (r'0|[afijkKoOpPStV\[\]]+', Keyword.Type),
 
             (r',', Punctuation),
-            (r'\n', Text, '#pop')
+            (r'\n', Whitespace, '#pop')
         ],
 
         'quoted string': [
@@ -376,7 +378,7 @@ class CsoundOrchestraLexer(CsoundLexer):
             include('whitespace and macro uses'),
             (r'"', String, 'quoted string'),
             (r'\{\{', String, 'Csound score'),
-            (r'\n', Text, '#pop')
+            (r'\n', Whitespace, '#pop')
         ],
         'Csound score': [
             (r'\}\}', String, '#pop'),
@@ -387,7 +389,7 @@ class CsoundOrchestraLexer(CsoundLexer):
             include('whitespace and macro uses'),
             (r'"', String, 'quoted string'),
             (r'\{\{', String, 'Python'),
-            (r'\n', Text, '#pop')
+            (r'\n', Whitespace, '#pop')
         ],
         'Python': [
             (r'\}\}', String, '#pop'),
@@ -398,7 +400,7 @@ class CsoundOrchestraLexer(CsoundLexer):
             include('whitespace and macro uses'),
             (r'"', String, 'quoted string'),
             (r'\{\{', String, 'Lua'),
-            (r'\n', Text, '#pop')
+            (r'\n', Whitespace, '#pop')
         ],
         'Lua': [
             (r'\}\}', String, '#pop'),
@@ -453,12 +455,12 @@ class CsoundDocumentLexer(RegexLexer):
         ],
 
         'tag': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'[\w.:-]+\s*=', Name.Attribute, 'attr'),
             (r'/?\s*>', Name.Tag, '#pop')
         ],
         'attr': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'".*?"', String, '#pop'),
             (r"'.*?'", String, '#pop'),
             (r'[^\s>]+', String, '#pop')