pygments.rb 1.2.0 → 2.1.0

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.urbi
     ~~~~~~~~~~~~~~~~~~~~
 
     Lexers for UrbiScript 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.
 """
 
@@ -117,11 +116,11 @@ class UrbiscriptLexer(ExtendedRegexLexer):
         ],
         'string.double': [
             (r'((?:\\\\|\\"|[^"])*?)(\\B\((\d+)\)\()', blob_callback),
-            (r'(\\\\|\\"|[^"])*?"', String.Double, '#pop'),
+            (r'(\\\\|\\[^\\]|[^"\\])*?"', String.Double, '#pop'),
         ],
         'string.single': [
             (r"((?:\\\\|\\'|[^'])*?)(\\B\((\d+)\)\()", blob_callback),
-            (r"(\\\\|\\'|[^'])*?'", String.Single, '#pop'),
+            (r"(\\\\|\\[^\\]|[^'\\])*?'", String.Single, '#pop'),
         ],
         # from http://pygments.org/docs/lexerdevelopment/#changing-states
         'comment': [
@@ -131,3 +130,16 @@ class UrbiscriptLexer(ExtendedRegexLexer):
             (r'[*/]', Comment.Multiline),
         ]
     }
+
+    def analyse_text(text):
+        """This is fairly similar to C and others, but freezeif and
+        waituntil are unique keywords."""
+        result = 0
+
+        if 'freezeif' in text:
+            result += 0.05
+
+        if 'waituntil' in text:
+            result += 0.05
+
+        return result

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

@@ -0,0 +1,89 @@
+"""
+    pygments.lexers.usd
+    ~~~~~~~~~~~~~~~~~~~
+
+    The module that parses Pixar's Universal Scene Description file format.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, bygroups
+from pygments.lexer import words as words_
+from pygments.lexers._usd_builtins import COMMON_ATTRIBUTES, KEYWORDS, \
+    OPERATORS, SPECIAL_NAMES, TYPES
+from pygments.token import Comment, Keyword, Name, Number, Operator, \
+    Punctuation, String, Text, Whitespace
+
+__all__ = ["UsdLexer"]
+
+
+def _keywords(words, type_):
+    return [(words_(words, prefix=r"\b", suffix=r"\b"), type_)]
+
+
+_TYPE = r"(\w+(?:\[\])?)"
+_BASE_ATTRIBUTE = r"(\w+(?:\:\w+)*)(?:(\.)(timeSamples))?"
+_WHITESPACE = r"([ \t]+)"
+
+
+class UsdLexer(RegexLexer):
+    """
+    A lexer that parses Pixar's Universal Scene Description file format.
+
+    .. versionadded:: 2.6
+    """
+
+    name = "USD"
+    aliases = ["usd", "usda"]
+    filenames = ["*.usd", "*.usda"]
+
+    tokens = {
+        "root": [
+            (r"(custom){_WHITESPACE}(uniform)(\s+){}(\s+){}(\s*)(=)".format(
+                _TYPE, _BASE_ATTRIBUTE, _WHITESPACE=_WHITESPACE),
+             bygroups(Keyword.Token, Whitespace, Keyword.Token, Whitespace,
+                      Keyword.Type, Whitespace, Name.Attribute, Text,
+                      Name.Keyword.Tokens, Whitespace, Operator)),
+            (r"(custom){_WHITESPACE}{}(\s+){}(\s*)(=)".format(
+                _TYPE, _BASE_ATTRIBUTE, _WHITESPACE=_WHITESPACE),
+             bygroups(Keyword.Token, Whitespace, Keyword.Type, Whitespace,
+                      Name.Attribute, Text, Name.Keyword.Tokens, Whitespace,
+                      Operator)),
+            (r"(uniform){_WHITESPACE}{}(\s+){}(\s*)(=)".format(
+                _TYPE, _BASE_ATTRIBUTE, _WHITESPACE=_WHITESPACE),
+             bygroups(Keyword.Token, Whitespace, Keyword.Type, Whitespace,
+                      Name.Attribute, Text, Name.Keyword.Tokens, Whitespace,
+                      Operator)),
+            (r"{}{_WHITESPACE}{}(\s*)(=)".format(
+                _TYPE, _BASE_ATTRIBUTE, _WHITESPACE=_WHITESPACE),
+             bygroups(Keyword.Type, Whitespace, Name.Attribute, Text,
+                      Name.Keyword.Tokens, Whitespace, Operator)),
+        ] +
+        _keywords(KEYWORDS, Keyword.Tokens) +
+        _keywords(SPECIAL_NAMES, Name.Builtins) +
+        _keywords(COMMON_ATTRIBUTES, Name.Attribute) +
+        [(r"\b\w+:[\w:]+\b", Name.Attribute)] +
+        _keywords(OPERATORS, Operator) +  # more attributes
+        [(type_ + r"\[\]", Keyword.Type) for type_ in TYPES] +
+        _keywords(TYPES, Keyword.Type) +
+        [
+            (r"[(){}\[\]]", Punctuation),
+            ("#.*?$", Comment.Single),
+            (",", Punctuation),
+            (";", Punctuation),  # ";"s are allowed to combine separate metadata lines
+            ("=", Operator),
+            (r"[-]*([0-9]*[.])?[0-9]+(?:e[+-]*\d+)?", Number),
+            (r"'''(?:.|\n)*?'''", String),
+            (r'"""(?:.|\n)*?"""', String),
+            (r"'.*?'", String),
+            (r'".*?"', String),
+            (r"<(\.\./)*([\w/]+|[\w/]+\.\w+[\w:]*)>", Name.Namespace),
+            (r"@.*?@", String.Interpol),
+            (r'\(.*"[.\\n]*".*\)', String.Doc),
+            (r"\A#usda .+$", Comment.Hashbang),
+            (r"\s+", Whitespace),
+            (r"\w+", Text),
+            (r"[_:.]+", Punctuation),
+        ],
+    }

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.varnish
     ~~~~~~~~~~~~~~~~~~~~~~~
 
     Lexers for Varnish configuration
 
-    :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.
 """
 
@@ -36,7 +35,7 @@ class VCLLexer(RegexLexer):
         # Skip over comments and blank lines
         # This is accurate enough that returning 0.9 is reasonable.
         # Almost no VCL files start without some comments.
-        elif '\nvcl 4\.0;' in text[:1000]:
+        elif '\nvcl 4.0;' in text[:1000]:
             return 0.9
 
     tokens = {
@@ -61,7 +60,7 @@ class VCLLexer(RegexLexer):
              bygroups(Name.Attribute, Operator, Name.Variable.Global, Punctuation)),
             (r'(\.probe)(\s*=\s*)(\{)',
              bygroups(Name.Attribute, Operator, Punctuation), 'probe'),
-            (r'(\.\w+\b)(\s*=\s*)([^;]*)(\s*;)',
+            (r'(\.\w+\b)(\s*=\s*)([^;\s]*)(\s*;)',
              bygroups(Name.Attribute, Operator, using(this), Punctuation)),
             (r'\{', Punctuation, '#push'),
             (r'\}', Punctuation, '#pop'),
@@ -120,7 +119,7 @@ class VCLLexer(RegexLexer):
              r'([a-zA-Z_]\w*)'
              r'(\s*\(.*\))',
              bygroups(Name.Function, Punctuation, Name.Function, using(this))),
-            ('[a-zA-Z_]\w*', Name),
+            (r'[a-zA-Z_]\w*', Name),
         ],
         'comment': [
             (r'[^*/]+', Comment.Multiline),

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

@@ -1,17 +1,16 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.verification
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Lexer for Intermediate Verification Languages (IVLs).
 
-    :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.
 """
 
 from pygments.lexer import RegexLexer, include, words
 from pygments.token import Comment, Operator, Keyword, Name, Number, \
-    Punctuation, Whitespace
+    Punctuation, Text, Generic
 
 __all__ = ['BoogieLexer', 'SilverLexer']
 
@@ -29,8 +28,9 @@ class BoogieLexer(RegexLexer):
     tokens = {
         'root': [
             # Whitespace and Comments
-            (r'\n', Whitespace),
-            (r'\s+', Whitespace),
+            (r'\n', Text),
+            (r'\s+', Text),
+            (r'\\\n', Text),  # line continuation
             (r'//[/!](.*?)\n', Comment.Doc),
             (r'//(.*?)\n', Comment.Single),
             (r'/\*', Comment.Multiline, 'comment'),
@@ -45,6 +45,7 @@ class BoogieLexer(RegexLexer):
             (words(('bool', 'int', 'ref'), suffix=r'\b'), Keyword.Type),
             include('numbers'),
             (r"(>=|<=|:=|!=|==>|&&|\|\||[+/\-=>*<\[\]])", Operator),
+            (r'\{.*?\}', Generic.Emph), #triggers
             (r"([{}():;,.])", Punctuation),
             # Identifier
             (r'[a-zA-Z_]\w*', Name),
@@ -74,8 +75,9 @@ class SilverLexer(RegexLexer):
     tokens = {
         'root': [
             # Whitespace and Comments
-            (r'\n', Whitespace),
-            (r'\s+', Whitespace),
+            (r'\n', Text),
+            (r'\s+', Text),
+            (r'\\\n', Text),  # line continuation
             (r'//[/!](.*?)\n', Comment.Doc),
             (r'//(.*?)\n', Comment.Single),
             (r'/\*', Comment.Multiline, 'comment'),
@@ -83,18 +85,18 @@ class SilverLexer(RegexLexer):
             (words((
                 'result', 'true', 'false', 'null', 'method', 'function',
                 'predicate', 'program', 'domain', 'axiom', 'var', 'returns',
-                'field', 'define', 'requires', 'ensures', 'invariant',
-                'fold', 'unfold', 'inhale', 'exhale', 'new', 'assert',
+                'field', 'define', 'fold', 'unfold', 'inhale', 'exhale', 'new', 'assert',
                 'assume', 'goto', 'while', 'if', 'elseif', 'else', 'fresh',
                 'constraining', 'Seq', 'Set', 'Multiset', 'union', 'intersection',
                 'setminus', 'subset', 'unfolding', 'in', 'old', 'forall', 'exists',
                 'acc', 'wildcard', 'write', 'none', 'epsilon', 'perm', 'unique',
                 'apply', 'package', 'folding', 'label', 'forperm'),
              suffix=r'\b'), Keyword),
-            (words(('Int', 'Perm', 'Bool', 'Ref'), suffix=r'\b'), Keyword.Type),
+            (words(('requires', 'ensures', 'invariant'), suffix=r'\b'), Name.Decorator),
+            (words(('Int', 'Perm', 'Bool', 'Ref', 'Rational'), suffix=r'\b'), Keyword.Type),
             include('numbers'),
-
             (r'[!%&*+=|?:<>/\-\[\]]', Operator),
+            (r'\{.*?\}', Generic.Emph), #triggers
             (r'([{}():;,.])', Punctuation),
             # Identifier
             (r'[\w$]\w*', Name),

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.web
     ~~~~~~~~~~~~~~~~~~~
 
     Just export previously exported lexers.
 
-    :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.
 """
 

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

@@ -0,0 +1,298 @@
+"""
+    pygments.lexers.webidl
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for Web IDL, including some extensions.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, default, include, words
+from pygments.token import Comment, Keyword, Name, Number, Punctuation, \
+    String, Text
+
+__all__ = ['WebIDLLexer']
+
+_builtin_types = (
+    # primitive types
+    'byte', 'octet', 'boolean',
+    r'(?:unsigned\s+)?(?:short|long(?:\s+long)?)',
+    r'(?:unrestricted\s+)?(?:float|double)',
+    # string types
+    'DOMString', 'ByteString', 'USVString',
+    # exception types
+    'Error', 'DOMException',
+    # typed array types
+    'Uint8Array', 'Uint16Array', 'Uint32Array', 'Uint8ClampedArray',
+    'Float32Array', 'Float64Array',
+    # buffer source types
+    'ArrayBuffer', 'DataView', 'Int8Array', 'Int16Array', 'Int32Array',
+    # other
+    'any', 'void', 'object', 'RegExp',
+)
+_identifier = r'_?[A-Za-z][a-zA-Z0-9_-]*'
+_keyword_suffix = r'(?![\w-])'
+_string = r'"[^"]*"'
+
+
+class WebIDLLexer(RegexLexer):
+    """
+    For Web IDL.
+
+    .. versionadded:: 2.6
+    """
+
+    name = 'Web IDL'
+    aliases = ['webidl']
+    filenames = ['*.webidl']
+
+    tokens = {
+        'common': [
+            (r'\s+', Text),
+            (r'(?s)/\*.*?\*/', Comment.Multiline),
+            (r'//.*', Comment.Single),
+            (r'^#.*', Comment.Preproc),
+        ],
+        'root': [
+            include('common'),
+            (r'\[', Punctuation, 'extended_attributes'),
+            (r'partial' + _keyword_suffix, Keyword),
+            (r'typedef' + _keyword_suffix, Keyword, ('typedef', 'type')),
+            (r'interface' + _keyword_suffix, Keyword, 'interface_rest'),
+            (r'enum' + _keyword_suffix, Keyword, 'enum_rest'),
+            (r'callback' + _keyword_suffix, Keyword, 'callback_rest'),
+            (r'dictionary' + _keyword_suffix, Keyword, 'dictionary_rest'),
+            (r'namespace' + _keyword_suffix, Keyword, 'namespace_rest'),
+            (_identifier, Name.Class, 'implements_rest'),
+        ],
+        'extended_attributes': [
+            include('common'),
+            (r',', Punctuation),
+            (_identifier, Name.Decorator),
+            (r'=', Punctuation, 'extended_attribute_rest'),
+            (r'\(', Punctuation, 'argument_list'),
+            (r'\]', Punctuation, '#pop'),
+        ],
+        'extended_attribute_rest': [
+            include('common'),
+            (_identifier, Name, 'extended_attribute_named_rest'),
+            (_string, String),
+            (r'\(', Punctuation, 'identifier_list'),
+            default('#pop'),
+        ],
+        'extended_attribute_named_rest': [
+            include('common'),
+            (r'\(', Punctuation, 'argument_list'),
+            default('#pop'),
+        ],
+        'argument_list': [
+            include('common'),
+            (r'\)', Punctuation, '#pop'),
+            default('argument'),
+        ],
+        'argument': [
+            include('common'),
+            (r'optional' + _keyword_suffix, Keyword),
+            (r'\[', Punctuation, 'extended_attributes'),
+            (r',', Punctuation, '#pop'),
+            (r'\)', Punctuation, '#pop:2'),
+            default(('argument_rest', 'type'))
+        ],
+        'argument_rest': [
+            include('common'),
+            (_identifier, Name.Variable),
+            (r'\.\.\.', Punctuation),
+            (r'=', Punctuation, 'default_value'),
+            default('#pop'),
+        ],
+        'identifier_list': [
+            include('common'),
+            (_identifier, Name.Class),
+            (r',', Punctuation),
+            (r'\)', Punctuation, '#pop'),
+        ],
+        'type': [
+            include('common'),
+            (r'(?:' + r'|'.join(_builtin_types) + r')' + _keyword_suffix,
+             Keyword.Type, 'type_null'),
+            (words(('sequence', 'Promise', 'FrozenArray'),
+                   suffix=_keyword_suffix), Keyword.Type, 'type_identifier'),
+            (_identifier, Name.Class, 'type_identifier'),
+            (r'\(', Punctuation, 'union_type'),
+        ],
+        'union_type': [
+            include('common'),
+            (r'or' + _keyword_suffix, Keyword),
+            (r'\)', Punctuation, ('#pop', 'type_null')),
+            default('type'),
+        ],
+        'type_identifier': [
+            (r'<', Punctuation, 'type_list'),
+            default(('#pop', 'type_null'))
+        ],
+        'type_null': [
+            (r'\?', Punctuation),
+            default('#pop:2'),
+        ],
+        'default_value': [
+            include('common'),
+            include('const_value'),
+            (_string, String, '#pop'),
+            (r'\[\s*\]', Punctuation, '#pop'),
+        ],
+        'const_value': [
+            include('common'),
+            (words(('true', 'false', '-Infinity', 'Infinity', 'NaN', 'null'),
+                   suffix=_keyword_suffix), Keyword.Constant, '#pop'),
+            (r'-?(?:(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:[Ee][+-]?[0-9]+)?' +
+             r'|[0-9]+[Ee][+-]?[0-9]+)', Number.Float, '#pop'),
+            (r'-?[1-9][0-9]*', Number.Integer, '#pop'),
+            (r'-?0[Xx][0-9A-Fa-f]+', Number.Hex, '#pop'),
+            (r'-?0[0-7]*', Number.Oct, '#pop'),
+        ],
+        'typedef': [
+            include('common'),
+            (_identifier, Name.Class),
+            (r';', Punctuation, '#pop'),
+        ],
+        'namespace_rest': [
+            include('common'),
+            (_identifier, Name.Namespace),
+            (r'\{', Punctuation, 'namespace_body'),
+            (r';', Punctuation, '#pop'),
+        ],
+        'namespace_body': [
+            include('common'),
+            (r'\[', Punctuation, 'extended_attributes'),
+            (r'readonly' + _keyword_suffix, Keyword),
+            (r'attribute' + _keyword_suffix,
+             Keyword, ('attribute_rest', 'type')),
+            (r'const' + _keyword_suffix, Keyword, ('const_rest', 'type')),
+            (r'\}', Punctuation, '#pop'),
+            default(('operation_rest', 'type')),
+        ],
+        'interface_rest': [
+            include('common'),
+            (_identifier, Name.Class),
+            (r':', Punctuation),
+            (r'\{', Punctuation, 'interface_body'),
+            (r';', Punctuation, '#pop'),
+        ],
+        'interface_body': [
+            (words(('iterable', 'maplike', 'setlike'), suffix=_keyword_suffix),
+             Keyword, 'iterable_maplike_setlike_rest'),
+            (words(('setter', 'getter', 'creator', 'deleter', 'legacycaller',
+                    'inherit', 'static', 'stringifier', 'jsonifier'),
+                   suffix=_keyword_suffix), Keyword),
+            (r'serializer' + _keyword_suffix, Keyword, 'serializer_rest'),
+            (r';', Punctuation),
+            include('namespace_body'),
+        ],
+        'attribute_rest': [
+            include('common'),
+            (_identifier, Name.Variable),
+            (r';', Punctuation, '#pop'),
+        ],
+        'const_rest': [
+            include('common'),
+            (_identifier, Name.Constant),
+            (r'=', Punctuation, 'const_value'),
+            (r';', Punctuation, '#pop'),
+        ],
+        'operation_rest': [
+            include('common'),
+            (r';', Punctuation, '#pop'),
+            default('operation'),
+        ],
+        'operation': [
+            include('common'),
+            (_identifier, Name.Function),
+            (r'\(', Punctuation, 'argument_list'),
+            (r';', Punctuation, '#pop:2'),
+        ],
+        'iterable_maplike_setlike_rest': [
+            include('common'),
+            (r'<', Punctuation, 'type_list'),
+            (r';', Punctuation, '#pop'),
+        ],
+        'type_list': [
+            include('common'),
+            (r',', Punctuation),
+            (r'>', Punctuation, '#pop'),
+            default('type'),
+        ],
+        'serializer_rest': [
+            include('common'),
+            (r'=', Punctuation, 'serialization_pattern'),
+            (r';', Punctuation, '#pop'),
+            default('operation'),
+        ],
+        'serialization_pattern': [
+            include('common'),
+            (_identifier, Name.Variable, '#pop'),
+            (r'\{', Punctuation, 'serialization_pattern_map'),
+            (r'\[', Punctuation, 'serialization_pattern_list'),
+        ],
+        'serialization_pattern_map': [
+            include('common'),
+            (words(('getter', 'inherit', 'attribute'),
+                   suffix=_keyword_suffix), Keyword),
+            (r',', Punctuation),
+            (_identifier, Name.Variable),
+            (r'\}', Punctuation, '#pop:2'),
+        ],
+        'serialization_pattern_list': [
+            include('common'),
+            (words(('getter', 'attribute'), suffix=_keyword_suffix), Keyword),
+            (r',', Punctuation),
+            (_identifier, Name.Variable),
+            (r']', Punctuation, '#pop:2'),
+        ],
+        'enum_rest': [
+            include('common'),
+            (_identifier, Name.Class),
+            (r'\{', Punctuation, 'enum_body'),
+            (r';', Punctuation, '#pop'),
+        ],
+        'enum_body': [
+            include('common'),
+            (_string, String),
+            (r',', Punctuation),
+            (r'\}', Punctuation, '#pop'),
+        ],
+        'callback_rest': [
+            include('common'),
+            (r'interface' + _keyword_suffix,
+             Keyword, ('#pop', 'interface_rest')),
+            (_identifier, Name.Class),
+            (r'=', Punctuation, ('operation', 'type')),
+            (r';', Punctuation, '#pop'),
+        ],
+        'dictionary_rest': [
+            include('common'),
+            (_identifier, Name.Class),
+            (r':', Punctuation),
+            (r'\{', Punctuation, 'dictionary_body'),
+            (r';', Punctuation, '#pop'),
+        ],
+        'dictionary_body': [
+            include('common'),
+            (r'\[', Punctuation, 'extended_attributes'),
+            (r'required' + _keyword_suffix, Keyword),
+            (r'\}', Punctuation, '#pop'),
+            default(('dictionary_item', 'type')),
+        ],
+        'dictionary_item': [
+            include('common'),
+            (_identifier, Name.Variable),
+            (r'=', Punctuation, 'default_value'),
+            (r';', Punctuation, '#pop'),
+        ],
+        'implements_rest': [
+            include('common'),
+            (r'implements' + _keyword_suffix, Keyword),
+            (_identifier, Name.Class),
+            (r';', Punctuation, '#pop'),
+        ],
+    }