pygments.rb 2.3.1 → 2.4.0

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

@@ -4,34 +4,30 @@
 
     Lexers for Erlang.
 
-    :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 Lexer, RegexLexer, bygroups, words, do_insertions, \
-    include, default
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Generic
+    include, default, line_re
+from pygments.token import Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Generic, Whitespace
 
 __all__ = ['ErlangLexer', 'ErlangShellLexer', 'ElixirConsoleLexer',
            'ElixirLexer']
 
 
-line_re = re.compile('.*?\n')
-
-
 class ErlangLexer(RegexLexer):
     """
     For the Erlang functional programming language.
 
-    Blame Jeremy Thurgood (http://jerith.za.net/).
-
     .. versionadded:: 0.9
     """
 
     name = 'Erlang'
+    url = 'https://www.erlang.org/'
     aliases = ['erlang']
     filenames = ['*.erl', '*.hrl', '*.es', '*.escript']
     mimetypes = ['text/x-erlang']
@@ -93,8 +89,8 @@ class ErlangLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'\s+', Text),
-            (r'%.*\n', Comment),
+            (r'\s+', Whitespace),
+            (r'(%.*)(\n)', bygroups(Comment, Whitespace)),
             (words(keywords, suffix=r'\b'), Keyword),
             (words(builtins, suffix=r'\b'), Name.Builtin),
             (words(word_operators, suffix=r'\b'), Operator.Word),
@@ -105,7 +101,7 @@ class ErlangLexer(RegexLexer):
             (r'>>', Name.Label),
             ('(' + atom_re + ')(:)', bygroups(Name.Namespace, Punctuation)),
             ('(?:^|(?<=:))(' + atom_re + r')(\s*)(\()',
-             bygroups(Name.Function, Text, Punctuation)),
+             bygroups(Name.Function, Whitespace, Punctuation)),
             (r'[+-]?' + base_re + r'#[0-9a-zA-Z]+', Number.Integer),
             (r'[+-]?\d+', Number.Integer),
             (r'[+-]?\d+.\d+', Number.Float),
@@ -132,9 +128,9 @@ class ErlangLexer(RegexLexer):
         ],
         'directive': [
             (r'(define)(\s*)(\()('+macro_re+r')',
-             bygroups(Name.Entity, Text, Punctuation, Name.Constant), '#pop'),
+             bygroups(Name.Entity, Whitespace, Punctuation, Name.Constant), '#pop'),
             (r'(record)(\s*)(\()('+macro_re+r')',
-             bygroups(Name.Entity, Text, Punctuation, Name.Label), '#pop'),
+             bygroups(Name.Entity, Whitespace, Punctuation, Name.Label), '#pop'),
             (atom_re, Name.Entity, '#pop'),
         ],
         'map_key': [
@@ -223,12 +219,13 @@ def gen_elixir_sigstr_rules(term, term_class, token, interpol=True):
 
 class ElixirLexer(RegexLexer):
     """
-    For the `Elixir language <http://elixir-lang.org>`_.
+    For the Elixir language.
 
     .. versionadded:: 1.5
     """
 
     name = 'Elixir'
+    url = 'http://elixir-lang.org'
     aliases = ['elixir', 'ex', 'exs']
     filenames = ['*.ex', '*.eex', '*.exs', '*.leex']
     mimetypes = ['text/x-elixir']
@@ -317,11 +314,11 @@ class ElixirLexer(RegexLexer):
                 default('#pop'),
             ]
             states[name + '-intp'] = [
-                (r'^\s*' + term, String.Heredoc, '#pop'),
+                (r'^(\s*)(' + term + ')', bygroups(Whitespace, String.Heredoc), '#pop'),
                 include('heredoc_interpol'),
             ]
             states[name + '-no-intp'] = [
-                (r'^\s*' + term, String.Heredoc, '#pop'),
+                (r'^(\s*)(' + term +')', bygroups(Whitespace, String.Heredoc), '#pop'),
                 include('heredoc_no_interpol'),
             ]
 
@@ -354,7 +351,7 @@ class ElixirLexer(RegexLexer):
 
     tokens = {
         'root': [
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'#.*$', Comment.Single),
 
             # Various kinds of characters
@@ -403,8 +400,10 @@ class ElixirLexer(RegexLexer):
             (r'\d(_?\d)*', Number.Integer),
 
             # strings and heredocs
-            (r'"""\s*', String.Heredoc, 'heredoc_double'),
-            (r"'''\s*$", String.Heredoc, 'heredoc_single'),
+            (r'(""")(\s*)', bygroups(String.Heredoc, Whitespace),
+                'heredoc_double'),
+            (r"(''')(\s*)$", bygroups(String.Heredoc, Whitespace),
+                'heredoc_single'),
             (r'"', String.Double, 'string_double'),
             (r"'", String.Single, 'string_single'),
 
@@ -414,7 +413,7 @@ class ElixirLexer(RegexLexer):
             (r'\{', Punctuation, 'tuple'),
         ],
         'heredoc_double': [
-            (r'^\s*"""', String.Heredoc, '#pop'),
+            (r'^(\s*)(""")', bygroups(Whitespace, String.Heredoc), '#pop'),
             include('heredoc_interpol'),
         ],
         'heredoc_single': [
@@ -431,7 +430,7 @@ class ElixirLexer(RegexLexer):
         'heredoc_no_interpol': [
             (r'[^\\\n]+', String.Heredoc),
             (r'\\.', String.Heredoc),
-            (r'\n+', String.Heredoc),
+            (r'\n+', Whitespace),
         ],
         'escapes': [
             (long_hex_char_re,

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

@@ -4,15 +4,13 @@
 
     Lexers for esoteric 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.
 """
 
-from pygments.lexer import RegexLexer, include, words
-from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Error
-
-import re
+from pygments.lexer import RegexLexer, include, words, bygroups
+from pygments.token import Comment, Operator, Keyword, Name, String, Number, \
+    Punctuation, Error, Whitespace
 
 __all__ = ['BrainfuckLexer', 'BefungeLexer', 'RedcodeLexer', 'CAmkESLexer',
            'CapDLLexer', 'AheuiLexer']
@@ -20,11 +18,11 @@ __all__ = ['BrainfuckLexer', 'BefungeLexer', 'RedcodeLexer', 'CAmkESLexer',
 
 class BrainfuckLexer(RegexLexer):
     """
-    Lexer for the esoteric `BrainFuck <http://www.muppetlabs.com/~breadbox/bf/>`_
-    language.
+    Lexer for the esoteric BrainFuck language.
     """
 
     name = 'Brainfuck'
+    url = 'http://www.muppetlabs.com/~breadbox/bf/'
     aliases = ['brainfuck', 'bf']
     filenames = ['*.bf', '*.b']
     mimetypes = ['application/x-brainfuck']
@@ -77,12 +75,12 @@ class BrainfuckLexer(RegexLexer):
 
 class BefungeLexer(RegexLexer):
     """
-    Lexer for the esoteric `Befunge <http://en.wikipedia.org/wiki/Befunge>`_
-    language.
+    Lexer for the esoteric Befunge language.
 
     .. versionadded:: 0.7
     """
     name = 'Befunge'
+    url = 'http://en.wikipedia.org/wiki/Befunge'
     aliases = ['befunge']
     filenames = ['*.befunge']
     mimetypes = ['application/x-befunge']
@@ -100,31 +98,32 @@ class BefungeLexer(RegexLexer):
             (r'[#;]', Comment),                   # Trampoline... depends on direction hit
             (r'[pg&~=@iotsy]', Keyword),          # Misc
             (r'[()A-Z]', Comment),                # Fingerprints
-            (r'\s+', Text),                       # Whitespace doesn't matter
+            (r'\s+', Whitespace),                 # Whitespace doesn't matter
         ],
     }
 
 
 class CAmkESLexer(RegexLexer):
     """
-    Basic lexer for the input language for the
-    `CAmkES <https://sel4.systems/CAmkES/>`_ component platform.
+    Basic lexer for the input language for the CAmkES component platform.
 
     .. versionadded:: 2.1
     """
     name = 'CAmkES'
+    url = 'https://sel4.systems/CAmkES/'
     aliases = ['camkes', 'idl4']
     filenames = ['*.camkes', '*.idl4']
 
     tokens = {
         'root': [
             # C pre-processor directive
-            (r'^\s*#.*\n', Comment.Preproc),
+            (r'^(\s*)(#.*)(\n)', bygroups(Whitespace, Comment.Preproc, 
+                Whitespace)),
 
             # Whitespace, comments
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'/\*(.|\n)*?\*/', Comment),
-            (r'//.*\n', Comment),
+            (r'//.*$', Comment),
 
             (r'[\[(){},.;\]]', Punctuation),
             (r'[~!%^&*+=|?:<>/-]', Operator),
@@ -152,10 +151,12 @@ class CAmkESLexer(RegexLexer):
                 Keyword.Reserved),
 
             # CAmkES-level include
-            (r'import\s+(<[^>]*>|"[^"]*");', Comment.Preproc),
+            (r'(import)(\s+)((?:<[^>]*>|"[^"]*");)',
+                bygroups(Comment.Preproc, Whitespace, Comment.Preproc)),
 
             # C-level include
-            (r'include\s+(<[^>]*>|"[^"]*");', Comment.Preproc),
+            (r'(include)(\s+)((?:<[^>]*>|"[^"]*");)',
+                bygroups(Comment.Preproc, Whitespace, Comment.Preproc)),
 
             # Literals
             (r'0[xX][\da-fA-F]+', Number.Hex),
@@ -172,8 +173,7 @@ class CAmkESLexer(RegexLexer):
 
 class CapDLLexer(RegexLexer):
     """
-    Basic lexer for
-    `CapDL <https://ssrg.nicta.com.au/publications/nictaabstracts/Kuz_KLW_10.abstract.pml>`_.
+    Basic lexer for CapDL.
 
     The source of the primary tool that reads such specifications is available
     at https://github.com/seL4/capdl/tree/master/capDL-tool. Note that this
@@ -185,18 +185,20 @@ class CapDLLexer(RegexLexer):
     .. versionadded:: 2.2
     """
     name = 'CapDL'
+    url = 'https://ssrg.nicta.com.au/publications/nictaabstracts/Kuz_KLW_10.abstract.pml'
     aliases = ['capdl']
     filenames = ['*.cdl']
 
     tokens = {
         'root': [
             # C pre-processor directive
-            (r'^\s*#.*\n', Comment.Preproc),
+            (r'^(\s*)(#.*)(\n)',
+                bygroups(Whitespace, Comment.Preproc, Whitespace)),
 
             # Whitespace, comments
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r'/\*(.|\n)*?\*/', Comment),
-            (r'(//|--).*\n', Comment),
+            (r'(//|--).*$', Comment),
 
             (r'[<>\[(){},:;=\]]', Punctuation),
             (r'\.\.', Punctuation),
@@ -248,7 +250,7 @@ class RedcodeLexer(RegexLexer):
     tokens = {
         'root': [
             # Whitespace:
-            (r'\s+', Text),
+            (r'\s+', Whitespace),
             (r';.*$', Comment.Single),
             # Lexemes:
             #  Identifiers
@@ -267,15 +269,11 @@ class RedcodeLexer(RegexLexer):
 
 class AheuiLexer(RegexLexer):
     """
-    Aheui_ Lexer.
-
-    Aheui_ is esoteric language based on Korean alphabets.
-
-    .. _Aheui: http://aheui.github.io/
-
+    Aheui is esoteric language based on Korean alphabets.
     """
 
     name = 'Aheui'
+    url = 'http://aheui.github.io/'
     aliases = ['aheui']
     filenames = ['*.aheui']
 

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

@@ -4,36 +4,37 @@
 
     Pygments lexers for Ezhil 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 Keyword, Text, Comment, Name
-from pygments.token import String, Number, Punctuation, Operator
+from pygments.token import Keyword, Comment, Name, String, Number, \
+    Punctuation, Operator, Whitespace
 
 __all__ = ['EzhilLexer']
 
 
 class EzhilLexer(RegexLexer):
     """
-    Lexer for `Ezhil, a Tamil script-based programming language <http://ezhillang.org>`_
+    Lexer for Ezhil, a Tamil script-based programming language.
 
     .. versionadded:: 2.1
     """
     name = 'Ezhil'
+    url = 'http://ezhillang.org'
     aliases = ['ezhil']
     filenames = ['*.n']
     mimetypes = ['text/x-ezhil']
-    flags = re.MULTILINE | re.UNICODE
     # Refer to tamil.utf8.tamil_letters from open-tamil for a stricter version of this.
     # This much simpler version is close enough, and includes combining marks.
     _TALETTERS = '[a-zA-Z_]|[\u0b80-\u0bff]'
     tokens = {
         'root': [
             include('keywords'),
-            (r'#.*\n', Comment.Single),
+            (r'#.*$', Comment.Single),
             (r'[@+/*,^\-%]|[!<>=]=?|&&?|\|\|?', Operator),
             ('இல்', Operator.Word),
             (words(('assert', 'max', 'min',
@@ -45,7 +46,7 @@ class EzhilLexer(RegexLexer):
                     'exp', 'log', 'log10', 'exit',
                     ), suffix=r'\b'), Name.Builtin),
             (r'(True|False)\b', Keyword.Constant),
-            (r'[^\S\n]+', Text),
+            (r'[^\S\n]+', Whitespace),
             include('identifier'),
             include('literal'),
             (r'[(){}\[\]:;.]', Punctuation),
@@ -58,8 +59,8 @@ class EzhilLexer(RegexLexer):
         ],
         'literal': [
             (r'".*?"', String),
-            (r'(?u)\d+((\.\d*)?[eE][+-]?\d+|\.\d*)', Number.Float),
-            (r'(?u)\d+', Number.Integer),
+            (r'\d+((\.\d*)?[eE][+-]?\d+|\.\d*)', Number.Float),
+            (r'\d+', Number.Integer),
         ]
     }