pygments.rb 1.2.0 → 2.1.0

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.dylan
     ~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for the Dylan language.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -32,27 +31,27 @@ class DylanLexer(RegexLexer):
 
     flags = re.IGNORECASE
 
-    builtins = set((
+    builtins = {
         'subclass', 'abstract', 'block', 'concrete', 'constant', 'class',
         'compiler-open', 'compiler-sideways', 'domain', 'dynamic',
         'each-subclass', 'exception', 'exclude', 'function', 'generic',
         'handler', 'inherited', 'inline', 'inline-only', 'instance',
         'interface', 'import', 'keyword', 'library', 'macro', 'method',
         'module', 'open', 'primary', 'required', 'sealed', 'sideways',
-        'singleton', 'slot', 'thread', 'variable', 'virtual'))
+        'singleton', 'slot', 'thread', 'variable', 'virtual'}
 
-    keywords = set((
+    keywords = {
         'above', 'afterwards', 'begin', 'below', 'by', 'case', 'cleanup',
         'create', 'define', 'else', 'elseif', 'end', 'export', 'finally',
         'for', 'from', 'if', 'in', 'let', 'local', 'otherwise', 'rename',
         'select', 'signal', 'then', 'to', 'unless', 'until', 'use', 'when',
-        'while'))
+        'while'}
 
-    operators = set((
+    operators = {
         '~', '+', '-', '*', '|', '^', '=', '==', '~=', '~==', '<', '<=',
-        '>', '>=', '&', '|'))
+        '>', '>=', '&', '|'}
 
-    functions = set((
+    functions = {
         'abort', 'abs', 'add', 'add!', 'add-method', 'add-new', 'add-new!',
         'all-superclasses', 'always', 'any?', 'applicable-method?', 'apply',
         'aref', 'aref-setter', 'as', 'as-lowercase', 'as-lowercase!',
@@ -86,7 +85,7 @@ class DylanLexer(RegexLexer):
         'subtype?', 'table-protocol', 'tail', 'tail-setter', 'third',
         'third-setter', 'truncate', 'truncate/', 'type-error-expected-type',
         'type-error-value', 'type-for-copy', 'type-union', 'union', 'values',
-        'vector', 'zero?'))
+        'vector', 'zero?'}
 
     valid_name = '\\\\?[\\w!&*<>|^$%@\\-+~?/=]+'
 
@@ -179,10 +178,10 @@ class DylanLexer(RegexLexer):
             (valid_name + ':', Keyword),
 
             # class names
-            (r'<' + valid_name + '>', Name.Class),
+            ('<' + valid_name + '>', Name.Class),
 
             # define variable forms.
-            (r'\*' + valid_name + '\*', Name.Variable.Global),
+            (r'\*' + valid_name + r'\*', Name.Variable.Global),
 
             # define constant forms.
             (r'\$' + valid_name, Name.Constant),
@@ -260,7 +259,7 @@ class DylanConsoleLexer(Lexer):
     mimetypes = ['text/x-dylan-console']
 
     _line_re = re.compile('.*?\n')
-    _prompt_re = re.compile('\?| ')
+    _prompt_re = re.compile(r'\?| ')
 
     def get_tokens_unprocessed(self, text):
         dylexer = DylanLexer(**self.options)
@@ -277,13 +276,11 @@ class DylanConsoleLexer(Lexer):
                 curcode += line[end:]
             else:
                 if curcode:
-                    for item in do_insertions(insertions,
-                                              dylexer.get_tokens_unprocessed(curcode)):
-                        yield item
+                    yield from do_insertions(insertions,
+                                             dylexer.get_tokens_unprocessed(curcode))
                     curcode = ''
                     insertions = []
                 yield match.start(), Generic.Output, line
         if curcode:
-            for item in do_insertions(insertions,
-                                      dylexer.get_tokens_unprocessed(curcode)):
-                yield item
+            yield from do_insertions(insertions,
+                                     dylexer.get_tokens_unprocessed(curcode))

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.ecl
     ~~~~~~~~~~~~~~~~~~~
 
     Lexers for the ECL language.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -13,7 +12,7 @@ import re
 
 from pygments.lexer import RegexLexer, include, bygroups, words
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
-    Number, Punctuation, Error
+    Number, Punctuation
 
 __all__ = ['ECLLexer']
 
@@ -21,7 +20,7 @@ __all__ = ['ECLLexer']
 class ECLLexer(RegexLexer):
     """
     Lexer for the declarative big-data `ECL
-    <http://hpccsystems.com/community/docs/ecl-language-reference/html>`_
+    <https://hpccsystems.com/training/documentation/ecl-language-reference/html>`_
     language.
 
     .. versionadded:: 1.5
@@ -56,7 +55,6 @@ class ECLLexer(RegexLexer):
             (r'0x[0-9a-f]+[lu]*', Number.Hex),
             (r'0[0-7]+[lu]*', Number.Oct),
             (r'\d+[lu]*', Number.Integer),
-            (r'\*/', Error),
             (r'[~!%^&*+=|?:<>/-]+', Operator),
             (r'[{}()\[\],.;]', Punctuation),
             (r'[a-z_]\w*', Name),
@@ -123,3 +121,17 @@ class ECLLexer(RegexLexer):
             (r'[^"\']+', String),
         ],
     }
+
+    def analyse_text(text):
+        """This is very difficult to guess relative to other business languages.
+        -> in conjuction with BEGIN/END seems relatively rare though."""
+        result = 0
+
+        if '->' in text:
+            result += 0.01
+        if 'BEGIN' in text:
+            result += 0.01
+        if 'END' in text:
+            result += 0.01
+
+        return result

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.eiffel
     ~~~~~~~~~~~~~~~~~~~~~~
 
     Lexer for the Eiffel language.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -45,7 +44,7 @@ class EiffelLexer(RegexLexer):
                 'require', 'rescue', 'retry', 'select', 'separate', 'then',
                 'undefine', 'until', 'variant', 'when'), prefix=r'(?i)\b', suffix=r'\b'),
              Keyword.Reserved),
-            (r'"\[(([^\]%]|\n)|%(.|\n)|\][^"])*?\]"', String),
+            (r'"\[([^\]%]|%(.|\n)|\][^"])*?\]"', String),
             (r'"([^"%\n]|%.)*?"', String),
             include('numbers'),
             (r"'([^'%]|%'|%%)'", String.Char),

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.elm
     ~~~~~~~~~~~~~~~~~~~
 
     Lexer for the Elm programming language.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -27,7 +26,7 @@ class ElmLexer(RegexLexer):
     filenames = ['*.elm']
     mimetypes = ['text/x-elm']
 
-    validName = r'[a-z_][a-zA-Z_\']*'
+    validName = r'[a-z_][a-zA-Z0-9_\']*'
 
     specialName = r'^main '
 
@@ -40,7 +39,7 @@ class ElmLexer(RegexLexer):
     reservedWords = words((
         'alias', 'as', 'case', 'else', 'if', 'import', 'in',
         'let', 'module', 'of', 'port', 'then', 'type', 'where',
-        ), suffix=r'\b')
+    ), suffix=r'\b')
 
     tokens = {
         'root': [
@@ -68,7 +67,7 @@ class ElmLexer(RegexLexer):
             (reservedWords, Keyword.Reserved),
 
             # Types
-            (r'[A-Z]\w*', Keyword.Type),
+            (r'[A-Z][a-zA-Z0-9_]*', Keyword.Type),
 
             # Main
             (specialName, Keyword.Reserved),
@@ -77,7 +76,7 @@ class ElmLexer(RegexLexer):
             (words((builtinOps), prefix=r'\(', suffix=r'\)'), Name.Function),
 
             # Infix Operators
-            (words((builtinOps)), Name.Function),
+            (words(builtinOps), Name.Function),
 
             # Numbers
             include('numbers'),

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

@@ -0,0 +1,150 @@
+"""
+    pygments.lexers.email
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for the raw E-mail.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, DelegatingLexer, bygroups
+from pygments.lexers.mime import MIMELexer
+from pygments.token import Text, Keyword, Name, String, Number, Comment
+from pygments.util import get_bool_opt
+
+__all__ = ["EmailLexer"]
+
+
+class EmailHeaderLexer(RegexLexer):
+    """
+    Sub-lexer for raw E-mail. This lexer only process header part of e-mail.
+
+    .. versionadded:: 2.5
+    """
+
+    def __init__(self, **options):
+        super().__init__(**options)
+        self.highlight_x = get_bool_opt(options, "highlight-X-header", False)
+
+    def get_x_header_tokens(self, match):
+        if self.highlight_x:
+            # field
+            yield match.start(1), Name.Tag, match.group(1)
+
+            # content
+            default_actions = self.get_tokens_unprocessed(
+                match.group(2), stack=("root", "header"))
+            yield from default_actions
+        else:
+            # lowlight
+            yield match.start(1), Comment.Special, match.group(1)
+            yield match.start(2), Comment.Multiline, match.group(2)
+
+    tokens = {
+        "root": [
+            (r"^(?:[A-WYZ]|X400)[\w\-]*:", Name.Tag, "header"),
+            (r"^(X-(?:\w[\w\-]*:))([\s\S]*?\n)(?![ \t])", get_x_header_tokens),
+        ],
+        "header": [
+            # folding
+            (r"\n[ \t]", Text.Whitespace),
+            (r"\n(?![ \t])", Text.Whitespace, "#pop"),
+
+            # keywords
+            (r"\bE?SMTPS?\b", Keyword),
+            (r"\b(?:HE|EH)LO\b", Keyword),
+
+            # mailbox
+            (r"[\w\.\-\+=]+@[\w\.\-]+", Name.Label),
+            (r"<[\w\.\-\+=]+@[\w\.\-]+>", Name.Label),
+
+            # domain
+            (r"\b(\w[\w\.-]*\.[\w\.-]*\w[a-zA-Z]+)\b", Name.Function),
+
+            # IPv4
+            (
+                r"(?<=\b)(?:(?:25[0-5]|2[0-4][0-9]|1?[0-9][0-9]?)\.){3}(?:25[0"
+                r"-5]|2[0-4][0-9]|1?[0-9][0-9]?)(?=\b)",
+                Number.Integer,
+            ),
+
+            # IPv6
+            (r"(?<=\b)([0-9a-fA-F]{1,4}:){1,7}:(?!\b)", Number.Hex),
+            (r"(?<=\b):((:[0-9a-fA-F]{1,4}){1,7}|:)(?=\b)", Number.Hex),
+            (r"(?<=\b)([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}(?=\b)", Number.Hex),
+            (r"(?<=\b)([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}(?=\b)", Number.Hex),
+            (r"(?<=\b)[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})(?=\b)", Number.Hex),
+            (r"(?<=\b)fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}(?=\b)", Number.Hex),
+            (r"(?<=\b)([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}(?=\b)", Number.Hex),
+            (r"(?<=\b)([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}(?=\b)",
+             Number.Hex),
+            (r"(?<=\b)([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}(?=\b)",
+             Number.Hex),
+            (r"(?<=\b)([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}(?=\b)",
+             Number.Hex),
+            (
+                r"(?<=\b)::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}"
+                r"[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}"
+                r"[0-9])(?=\b)",
+                Number.Hex,
+            ),
+            (
+                r"(?<=\b)([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-"
+                r"9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-"
+                r"9])(?=\b)",
+                Number.Hex,
+            ),
+
+            # Date time
+            (
+                r"(?:(Sun|Mon|Tue|Wed|Thu|Fri|Sat),\s+)?(0[1-9]|[1-2]?[0-9]|3["
+                r"01])\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+("
+                r"19[0-9]{2}|[2-9][0-9]{3})\s+(2[0-3]|[0-1][0-9]):([0-5][0-9])"
+                r"(?::(60|[0-5][0-9]))?(?:\.\d{1,5})?\s+([-\+][0-9]{2}[0-5][0-"
+                r"9]|\(?(?:UTC?|GMT|(?:E|C|M|P)(?:ST|ET|DT)|[A-IK-Z])\)?)",
+                Name.Decorator,
+            ),
+
+            # RFC-2047 encoded string
+            (
+                r"(=\?)([\w-]+)(\?)([BbQq])(\?)([\[\w!\"#$%&\'()*+,-./:;<=>@[\\"
+                r"\]^_`{|}~]+)(\?=)",
+                bygroups(
+                    String.Affix,
+                    Name.Constant,
+                    String.Affix,
+                    Keyword.Constant,
+                    String.Affix,
+                    Number.Hex,
+                    String.Affix
+                )
+            ),
+
+            # others
+            (r'[\s]+', Text.Whitespace),
+            (r'[\S]', Text),
+        ],
+    }
+
+
+class EmailLexer(DelegatingLexer):
+    """
+    Lexer for raw E-mail.
+
+    Additional options accepted:
+
+    `highlight-X-header`
+        Highlight the fields of ``X-`` user-defined email header. (default:
+        ``False``).
+
+    .. versionadded:: 2.5
+    """
+
+    name = "E-mail"
+    aliases = ["email", "eml"]
+    filenames = ["*.eml"]
+    mimetypes = ["message/rfc822"]
+
+    def __init__(self, **options):
+        super().__init__(EmailHeaderLexer, MIMELexer, Comment, **options)

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.erlang
     ~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for Erlang.
 
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -163,7 +162,7 @@ class ErlangShellLexer(Lexer):
     filenames = ['*.erl-sh']
     mimetypes = ['text/x-erl-shellsession']
 
-    _prompt_re = re.compile(r'\d+>(?=\s|\Z)')
+    _prompt_re = re.compile(r'(?:\([\w@_.]+\))?\d+>(?=\s|\Z)')
 
     def get_tokens_unprocessed(self, text):
         erlexer = ErlangLexer(**self.options)
@@ -180,9 +179,8 @@ class ErlangShellLexer(Lexer):
                 curcode += line[end:]
             else:
                 if curcode:
-                    for item in do_insertions(insertions,
-                                              erlexer.get_tokens_unprocessed(curcode)):
-                        yield item
+                    yield from do_insertions(insertions,
+                                             erlexer.get_tokens_unprocessed(curcode))
                     curcode = ''
                     insertions = []
                 if line.startswith('*'):
@@ -190,9 +188,8 @@ class ErlangShellLexer(Lexer):
                 else:
                     yield match.start(), Generic.Output, line
         if curcode:
-            for item in do_insertions(insertions,
-                                      erlexer.get_tokens_unprocessed(curcode)):
-                yield item
+            yield from do_insertions(insertions,
+                                     erlexer.get_tokens_unprocessed(curcode))
 
 
 def gen_elixir_string_rules(name, symbol, token):
@@ -207,10 +204,10 @@ def gen_elixir_string_rules(name, symbol, token):
     return states
 
 
-def gen_elixir_sigstr_rules(term, token, interpol=True):
+def gen_elixir_sigstr_rules(term, term_class, token, interpol=True):
     if interpol:
         return [
-            (r'[^#%s\\]+' % (term,), token),
+            (r'[^#%s\\]+' % (term_class,), token),
             include('escapes'),
             (r'\\.', token),
             (r'%s[a-zA-Z]*' % (term,), token, '#pop'),
@@ -218,7 +215,7 @@ def gen_elixir_sigstr_rules(term, token, interpol=True):
         ]
     else:
         return [
-            (r'[^%s\\]+' % (term,), token),
+            (r'[^%s\\]+' % (term_class,), token),
             (r'\\.', token),
             (r'%s[a-zA-Z]*' % (term,), token, '#pop'),
         ]
@@ -233,7 +230,7 @@ class ElixirLexer(RegexLexer):
 
     name = 'Elixir'
     aliases = ['elixir', 'ex', 'exs']
-    filenames = ['*.ex', '*.exs']
+    filenames = ['*.ex', '*.eex', '*.exs']
     mimetypes = ['text/x-elixir']
 
     KEYWORD = ('fn', 'do', 'end', 'after', 'else', 'rescue', 'catch')
@@ -291,14 +288,14 @@ class ElixirLexer(RegexLexer):
     def gen_elixir_sigil_rules():
         # all valid sigil terminators (excluding heredocs)
         terminators = [
-            (r'\{', r'\}', 'cb'),
-            (r'\[', r'\]', 'sb'),
-            (r'\(', r'\)', 'pa'),
-            (r'<', r'>', 'ab'),
-            (r'/', r'/', 'slas'),
-            (r'\|', r'\|', 'pipe'),
-            ('"', '"', 'quot'),
-            ("'", "'", 'apos'),
+            (r'\{', r'\}', '}',   'cb'),
+            (r'\[', r'\]', r'\]', 'sb'),
+            (r'\(', r'\)', ')',   'pa'),
+            ('<',   '>',   '>',   'ab'),
+            ('/',   '/',   '/',   'slas'),
+            (r'\|', r'\|', '|',   'pipe'),
+            ('"',   '"',   '"',   'quot'),
+            ("'",   "'",   "'",   'apos'),
         ]
 
         # heredocs have slightly different rules
@@ -328,14 +325,15 @@ class ElixirLexer(RegexLexer):
                 include('heredoc_no_interpol'),
             ]
 
-        for lterm, rterm, name in terminators:
+        for lterm, rterm, rterm_class, name in terminators:
             states['sigils'] += [
                 (r'~[a-z]' + lterm, token, name + '-intp'),
                 (r'~[A-Z]' + lterm, token, name + '-no-intp'),
             ]
-            states[name + '-intp'] = gen_elixir_sigstr_rules(rterm, token)
+            states[name + '-intp'] = \
+                gen_elixir_sigstr_rules(rterm, rterm_class, token)
             states[name + '-no-intp'] = \
-                gen_elixir_sigstr_rules(rterm, token, interpol=False)
+                gen_elixir_sigstr_rules(rterm, rterm_class, token, interpol=False)
 
         return states
 
@@ -344,7 +342,7 @@ class ElixirLexer(RegexLexer):
     op1_re = "|".join(re.escape(s) for s in OPERATORS1)
     ops_re = r'(?:%s|%s|%s)' % (op3_re, op2_re, op1_re)
     punctuation_re = "|".join(re.escape(s) for s in PUNCTUATION)
-    alnum = '\w'
+    alnum = r'\w'
     name_re = r'(?:\.\.\.|[a-z_]%s*[!?]?)' % alnum
     modname_re = r'[A-Z]%(alnum)s*(?:\.[A-Z]%(alnum)s*)*' % {'alnum': alnum}
     complex_name_re = r'(?:%s|%s|%s)' % (name_re, modname_re, ops_re)
@@ -495,7 +493,7 @@ class ElixirConsoleLexer(Lexer):
     aliases = ['iex']
     mimetypes = ['text/x-elixir-shellsession']
 
-    _prompt_re = re.compile('(iex|\.{3})(\(\d+\))?> ')
+    _prompt_re = re.compile(r'(iex|\.{3})((?:\([\w@_.]+\))?\d+|\(\d+\))?> ')
 
     def get_tokens_unprocessed(self, text):
         exlexer = ElixirLexer(**self.options)
@@ -505,7 +503,7 @@ class ElixirConsoleLexer(Lexer):
         insertions = []
         for match in line_re.finditer(text):
             line = match.group()
-            if line.startswith(u'** '):
+            if line.startswith('** '):
                 in_error = True
                 insertions.append((len(curcode),
                                    [(0, Generic.Error, line[:-1])]))
@@ -520,14 +518,12 @@ class ElixirConsoleLexer(Lexer):
                     curcode += line[end:]
                 else:
                     if curcode:
-                        for item in do_insertions(
-                                insertions, exlexer.get_tokens_unprocessed(curcode)):
-                            yield item
+                        yield from do_insertions(
+                            insertions, exlexer.get_tokens_unprocessed(curcode))
                         curcode = ''
                         insertions = []
                     token = Generic.Error if in_error else Generic.Output
                     yield match.start(), token, line
         if curcode:
-            for item in do_insertions(
-                    insertions, exlexer.get_tokens_unprocessed(curcode)):
-                yield item
+            yield from do_insertions(
+                insertions, exlexer.get_tokens_unprocessed(curcode))