pygments.rb 1.2.0 → 2.1.0

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.rust
     ~~~~~~~~~~~~~~~~~~~~
 
     Lexers for the Rust 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.
 """
 
@@ -18,48 +17,56 @@ __all__ = ['RustLexer']
 
 class RustLexer(RegexLexer):
     """
-    Lexer for the Rust programming language (version 1.10).
+    Lexer for the Rust programming language (version 1.47).
 
     .. versionadded:: 1.6
     """
     name = 'Rust'
     filenames = ['*.rs', '*.rs.in']
-    aliases = ['rust']
-    mimetypes = ['text/rust']
-
-    keyword_types = (
-        words(('u8', 'u16', 'u32', 'u64', 'i8', 'i16', 'i32', 'i64',
-               'usize', 'isize', 'f32', 'f64', 'str', 'bool'),
-              suffix=r'\b'),
-        Keyword.Type)
-
-    builtin_types = (words((
-        # Reexported core operators
-        'Copy', 'Send', 'Sized', 'Sync',
-        'Drop', 'Fn', 'FnMut', 'FnOnce',
-
-        # Reexported types and traits
-        'Box',
-        'ToOwned',
-        'Clone',
+    aliases = ['rust', 'rs']
+    mimetypes = ['text/rust', 'text/x-rust']
+
+    keyword_types = (words((
+        'u8', 'u16', 'u32', 'u64', 'u128', 'i8', 'i16', 'i32', 'i64', 'i128',
+        'usize', 'isize', 'f32', 'f64', 'char', 'str', 'bool',
+    ), suffix=r'\b'), Keyword.Type)
+
+    builtin_funcs_types = (words((
+        'Copy', 'Send', 'Sized', 'Sync', 'Unpin',
+        'Drop', 'Fn', 'FnMut', 'FnOnce', 'drop',
+        'Box', 'ToOwned', 'Clone',
         'PartialEq', 'PartialOrd', 'Eq', 'Ord',
-        'AsRef', 'AsMut', 'Into', 'From',
-        'Default',
-        'Iterator', 'Extend', 'IntoIterator',
-        'DoubleEndedIterator', 'ExactSizeIterator',
-        'Option',
-        'Some', 'None',
-        'Result',
-        'Ok', 'Err',
-        'SliceConcatExt',
-        'String', 'ToString',
-        'Vec'), suffix=r'\b'),
-        Name.Builtin)
+        'AsRef', 'AsMut', 'Into', 'From', 'Default',
+        'Iterator', 'Extend', 'IntoIterator', 'DoubleEndedIterator',
+        'ExactSizeIterator',
+        'Option', 'Some', 'None',
+        'Result', 'Ok', 'Err',
+        'String', 'ToString', 'Vec',
+    ), suffix=r'\b'), Name.Builtin)
+
+    builtin_macros = (words((
+        'asm', 'assert', 'assert_eq', 'assert_ne', 'cfg', 'column',
+        'compile_error', 'concat', 'concat_idents', 'dbg', 'debug_assert',
+        'debug_assert_eq', 'debug_assert_ne', 'env', 'eprint', 'eprintln',
+        'file', 'format', 'format_args', 'format_args_nl', 'global_asm',
+        'include', 'include_bytes', 'include_str',
+        'is_aarch64_feature_detected',
+        'is_arm_feature_detected',
+        'is_mips64_feature_detected',
+        'is_mips_feature_detected',
+        'is_powerpc64_feature_detected',
+        'is_powerpc_feature_detected',
+        'is_x86_feature_detected',
+        'line', 'llvm_asm', 'log_syntax', 'macro_rules', 'matches',
+        'module_path', 'option_env', 'panic', 'print', 'println', 'stringify',
+        'thread_local', 'todo', 'trace_macros', 'unimplemented', 'unreachable',
+        'vec', 'write', 'writeln',
+    ), suffix=r'!'), Name.Function.Magic)
 
     tokens = {
         'root': [
             # rust allows a file to start with a shebang, but if the first line
-            # starts with #![ then it’s not a shebang but a crate attribute.
+            # starts with #![ then it's not a shebang but a crate attribute.
             (r'#![^[\r\n].*$', Comment.Preproc),
             default('base'),
         ],
@@ -77,26 +84,26 @@ class RustLexer(RegexLexer):
             # Macro parameters
             (r"""\$([a-zA-Z_]\w*|\(,?|\),?|,?)""", Comment.Preproc),
             # Keywords
-            (words((
-                'as', 'box', 'const', 'crate', 'else', 'extern',
-                'for', 'if', 'impl', 'in', 'loop', 'match', 'move',
-                'mut', 'pub', 'ref', 'return', 'static', 'super',
-                'trait', 'unsafe', 'use', 'where', 'while'), suffix=r'\b'),
-             Keyword),
-            (words(('abstract', 'alignof', 'become', 'do', 'final', 'macro',
-                    'offsetof', 'override', 'priv', 'proc', 'pure', 'sizeof',
-                    'typeof', 'unsized', 'virtual', 'yield'), suffix=r'\b'),
-             Keyword.Reserved),
+            (words(('as', 'async', 'await', 'box', 'const', 'crate', 'dyn',
+                    'else', 'extern', 'for', 'if', 'impl', 'in', 'loop',
+                    'match', 'move', 'mut', 'pub', 'ref', 'return', 'static',
+                    'super', 'trait', 'unsafe', 'use', 'where', 'while'),
+                   suffix=r'\b'), Keyword),
+            (words(('abstract', 'become', 'do', 'final', 'macro', 'override',
+                    'priv', 'typeof', 'try', 'unsized', 'virtual', 'yield'),
+                   suffix=r'\b'), Keyword.Reserved),
             (r'(true|false)\b', Keyword.Constant),
+            (r'self\b', Name.Builtin.Pseudo),
             (r'mod\b', Keyword, 'modname'),
             (r'let\b', Keyword.Declaration),
             (r'fn\b', Keyword, 'funcname'),
             (r'(struct|enum|type|union)\b', Keyword, 'typename'),
             (r'(default)(\s+)(type|fn)\b', bygroups(Keyword, Text, Keyword)),
             keyword_types,
-            (r'self\b', Name.Builtin.Pseudo),
-            # Prelude (taken from Rust’s src/libstd/prelude.rs)
-            builtin_types,
+            (r'[sS]elf\b', Name.Builtin.Pseudo),
+            # Prelude (taken from Rust's src/libstd/prelude.rs)
+            builtin_funcs_types,
+            builtin_macros,
             # Path seperators, so types don't catch them.
             (r'::\b', Text),
             # Types in positions.
@@ -104,49 +111,47 @@ class RustLexer(RegexLexer):
             # Labels
             (r'(break|continue)(\s*)(\'[A-Za-z_]\w*)?',
              bygroups(Keyword, Text.Whitespace, Name.Label)),
-            # Character Literal
+
+            # Character literals
             (r"""'(\\['"\\nrt]|\\x[0-7][0-9a-fA-F]|\\0"""
              r"""|\\u\{[0-9a-fA-F]{1,6}\}|.)'""",
              String.Char),
             (r"""b'(\\['"\\nrt]|\\x[0-9a-fA-F]{2}|\\0"""
              r"""|\\u\{[0-9a-fA-F]{1,6}\}|.)'""",
              String.Char),
-            # Binary Literal
+
+            # Binary literals
             (r'0b[01_]+', Number.Bin, 'number_lit'),
-            # Octal Literal
+            # Octal literals
             (r'0o[0-7_]+', Number.Oct, 'number_lit'),
-            # Hexadecimal Literal
+            # Hexadecimal literals
             (r'0[xX][0-9a-fA-F_]+', Number.Hex, 'number_lit'),
-            # Decimal Literal
+            # Decimal literals
             (r'[0-9][0-9_]*(\.[0-9_]+[eE][+\-]?[0-9_]+|'
              r'\.[0-9_]*(?!\.)|[eE][+\-]?[0-9_]+)', Number.Float,
              'number_lit'),
             (r'[0-9][0-9_]*', Number.Integer, 'number_lit'),
-            # String Literal
+
+            # String literals
             (r'b"', String, 'bytestring'),
             (r'"', String, 'string'),
             (r'b?r(#*)".*?"\1', String),
 
-            # Lifetime
-            (r"""'static""", Name.Builtin),
-            (r"""'[a-zA-Z_]\w*""", Name.Attribute),
+            # Lifetime names
+            (r"'", Operator, 'lifetime'),
 
             # Operators and Punctuation
+            (r'\.\.=?', Operator),
             (r'[{}()\[\],.;]', Punctuation),
             (r'[+\-*/%&|<>^!~@=:?]', Operator),
 
-            # Identifier
+            # Identifiers
             (r'[a-zA-Z_]\w*', Name),
+            # Raw identifiers
+            (r'r#[a-zA-Z_]\w*', Name),
 
             # Attributes
             (r'#!?\[', Comment.Preproc, 'attribute['),
-            # Macros
-            (r'([A-Za-z_]\w*)(!)(\s*)([A-Za-z_]\w*)?(\s*)(\{)',
-             bygroups(Comment.Preproc, Punctuation, Whitespace, Name,
-                      Whitespace, Punctuation), 'macro{'),
-            (r'([A-Za-z_]\w*)(!)(\s*)([A-Za-z_]\w*)?(\()',
-             bygroups(Comment.Preproc, Punctuation, Whitespace, Name,
-                      Punctuation), 'macro('),
         ],
         'comment': [
             (r'[^*/]+', Comment.Multiline),
@@ -173,11 +178,17 @@ class RustLexer(RegexLexer):
         'typename': [
             (r'\s+', Text),
             (r'&', Keyword.Pseudo),
-            builtin_types,
+            (r"'", Operator, 'lifetime'),
+            builtin_funcs_types,
             keyword_types,
             (r'[a-zA-Z_]\w*', Name.Class, '#pop'),
             default('#pop'),
         ],
+        'lifetime': [
+            (r"(static|_)", Name.Builtin),
+            (r"[a-zA-Z_]+\w*", Name.Attribute),
+            default('#pop'),
+        ],
         'number_lit': [
             (r'[ui](8|16|32|64|size)', Keyword, '#pop'),
             (r'f(32|64)', Keyword, '#pop'),
@@ -194,14 +205,6 @@ class RustLexer(RegexLexer):
             (r"""\\x[89a-fA-F][0-9a-fA-F]""", String.Escape),
             include('string'),
         ],
-        'macro{': [
-            (r'\{', Operator, '#push'),
-            (r'\}', Operator, '#pop'),
-        ],
-        'macro(': [
-            (r'\(', Operator, '#push'),
-            (r'\)', Operator, '#pop'),
-        ],
         'attribute_common': [
             (r'"', String, 'string'),
             (r'\[', Comment.Preproc, 'attribute['),

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.sas
     ~~~~~~~~~~~~~~~~~~~
 
     Lexer for SAS.
 
-    :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/scdoc.py

@@ -0,0 +1,82 @@
+"""
+    pygments.lexers.scdoc
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for scdoc, a simple man page generator.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, include, bygroups, \
+    using, this
+from pygments.token import Text, Comment, Keyword, String, \
+    Generic
+
+
+__all__ = ['ScdocLexer']
+
+
+class ScdocLexer(RegexLexer):
+    """
+    `scdoc` is a simple man page generator for POSIX systems written in C99.
+    https://git.sr.ht/~sircmpwn/scdoc
+
+    .. versionadded:: 2.5
+    """
+    name = 'scdoc'
+    aliases = ['scdoc', 'scd']
+    filenames = ['*.scd', '*.scdoc']
+    flags = re.MULTILINE
+
+    tokens = {
+        'root': [
+            # comment
+            (r'^(;.+\n)', bygroups(Comment)),
+
+            # heading with pound prefix
+            (r'^(#)([^#].+\n)', bygroups(Generic.Heading, Text)),
+            (r'^(#{2})(.+\n)', bygroups(Generic.Subheading, Text)),
+            # bulleted lists
+            (r'^(\s*)([*-])(\s)(.+\n)',
+            bygroups(Text, Keyword, Text, using(this, state='inline'))),
+            # numbered lists
+            (r'^(\s*)(\.+\.)( .+\n)',
+            bygroups(Text, Keyword, using(this, state='inline'))),
+            # quote
+            (r'^(\s*>\s)(.+\n)', bygroups(Keyword, Generic.Emph)),
+            # text block
+            (r'^(```\n)([\w\W]*?)(^```$)', bygroups(String, Text, String)),
+
+            include('inline'),
+        ],
+        'inline': [
+            # escape
+            (r'\\.', Text),
+            # underlines
+            (r'(\s)(_[^_]+_)(\W|\n)', bygroups(Text, Generic.Emph, Text)),
+            # bold
+            (r'(\s)(\*[^*]+\*)(\W|\n)', bygroups(Text, Generic.Strong, Text)),
+            # inline code
+            (r'`[^`]+`', String.Backtick),
+
+            # general text, must come last!
+            (r'[^\\\s]+', Text),
+            (r'.', Text),
+        ],
+    }
+
+    def analyse_text(text):
+        """This is very similar to markdown, save for the escape characters
+        needed for * and _."""
+        result = 0
+
+        if '\\*' in text:
+            result += 0.01
+
+        if '\\_' in text:
+            result += 0.01
+
+        return result

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

@@ -1,11 +1,10 @@
-# -*- coding: utf-8 -*-
 """
     pygments.lexers.scripting
     ~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Lexer for scripting and embedded languages.
 
-    :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.
 """
 
@@ -15,11 +14,11 @@ from pygments.lexer import RegexLexer, include, bygroups, default, combined, \
     words
 from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
     Number, Punctuation, Error, Whitespace, Other
-from pygments.util import get_bool_opt, get_list_opt, iteritems
+from pygments.util import get_bool_opt, get_list_opt
 
 __all__ = ['LuaLexer', 'MoonScriptLexer', 'ChaiscriptLexer', 'LSLLexer',
            'AppleScriptLexer', 'RexxLexer', 'MOOCodeLexer', 'HybrisLexer',
-           'EasytrieveLexer', 'JclLexer']
+           'EasytrieveLexer', 'JclLexer', 'MiniScriptLexer']
 
 
 class LuaLexer(RegexLexer):
@@ -104,7 +103,7 @@ class LuaLexer(RegexLexer):
             (r'%s(?=%s*[.:])' % (_name, _s), Name.Class),
             (_name, Name.Function, '#pop'),
             # inline function
-            ('\(', Punctuation, '#pop'),
+            (r'\(', Punctuation, '#pop'),
         ],
 
         'goto': [
@@ -142,7 +141,7 @@ class LuaLexer(RegexLexer):
         self._functions = set()
         if self.func_name_highlighting:
             from pygments.lexers._lua_builtins import MODULES
-            for mod, func in iteritems(MODULES):
+            for mod, func in MODULES.items():
                 if mod not in self.disabled_modules:
                     self._functions.update(func)
         RegexLexer.__init__(self, **options)
@@ -157,12 +156,11 @@ class LuaLexer(RegexLexer):
                 elif '.' in value:
                     a, b = value.split('.')
                     yield index, Name, a
-                    yield index + len(a), Punctuation, u'.'
+                    yield index + len(a), Punctuation, '.'
                     yield index + len(a) + 1, Name, b
                     continue
             yield index, token, value
 
-
 class MoonScriptLexer(LuaLexer):
     """
     For `MoonScript <http://moonscript.org>`_ source code.
@@ -284,7 +282,7 @@ class ChaiscriptLexer(RegexLexer):
             (r'0x[0-9a-fA-F]+', Number.Hex),
             (r'[0-9]+', Number.Integer),
             (r'"', String.Double, 'dqstring'),
-            (r"'(\\\\|\\'|[^'])*'", String.Single),
+            (r"'(\\\\|\\[^\\]|[^'\\])*'", String.Single),
         ],
         'dqstring': [
             (r'\$\{[^"}]+?\}', String.Interpol),
@@ -660,18 +658,18 @@ class AppleScriptLexer(RegexLexer):
     tokens = {
         'root': [
             (r'\s+', Text),
-            (u'¬\\n', String.Escape),
+            (r'¬\n', String.Escape),
             (r"'s\s+", Text),  # This is a possessive, consider moving
             (r'(--|#).*?$', Comment),
             (r'\(\*', Comment.Multiline, 'comment'),
             (r'[(){}!,.:]', Punctuation),
-            (u'(«)([^»]+)(»)',
+            (r'(«)([^»]+)(»)',
              bygroups(Text, Name.Builtin, Text)),
             (r'\b((?:considering|ignoring)\s*)'
              r'(application responses|case|diacriticals|hyphens|'
              r'numeric strings|punctuation|white space)',
              bygroups(Keyword, Name.Builtin)),
-            (u'(-|\\*|\\+|&|≠|>=?|<=?|=|≥|≤|/|÷|\\^)', Operator),
+            (r'(-|\*|\+|&|≠|>=?|<=?|=|≥|≤|/|÷|\^)', Operator),
             (r"\b(%s)\b" % '|'.join(Operators), Operator.Word),
             (r'^(\s*(?:on|end)\s+)'
              r'(%s)' % '|'.join(StudioEvents[::-1]),
@@ -690,14 +688,14 @@ class AppleScriptLexer(RegexLexer):
             (r'\b(%s)s?\b' % '|'.join(StudioClasses), Name.Builtin),
             (r'\b(%s)\b' % '|'.join(StudioCommands), Name.Builtin),
             (r'\b(%s)\b' % '|'.join(References), Name.Builtin),
-            (r'"(\\\\|\\"|[^"])*"', String.Double),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String.Double),
             (r'\b(%s)\b' % Identifiers, Name.Variable),
             (r'[-+]?(\d+\.\d*|\d*\.\d+)(E[-+][0-9]+)?', Number.Float),
             (r'[-+]?\d+', Number.Integer),
         ],
         'comment': [
-            ('\(\*', Comment.Multiline, '#push'),
-            ('\*\)', Comment.Multiline, '#pop'),
+            (r'\(\*', Comment.Multiline, '#push'),
+            (r'\*\)', Comment.Multiline, '#pop'),
             ('[^*(]+', Comment.Multiline),
             ('[*(]', Comment.Multiline),
         ],
@@ -834,7 +832,7 @@ class MOOCodeLexer(RegexLexer):
             # Numbers
             (r'(0|[1-9][0-9_]*)', Number.Integer),
             # Strings
-            (r'"(\\\\|\\"|[^"])*"', String),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
             # exceptions
             (r'(E_PERM|E_DIV)', Name.Exception),
             # db-refs
@@ -925,7 +923,7 @@ class HybrisLexer(RegexLexer):
                 'Runnable', 'CGI', 'ClientSocket', 'Socket', 'ServerSocket',
                 'File', 'Console', 'Directory', 'Exception'), suffix=r'\b'),
              Keyword.Type),
-            (r'"(\\\\|\\"|[^"])*"', String),
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
             (r"'\\.'|'[^\\]'|'\\u[0-9a-f]{4}'", String.Char),
             (r'(\.)([a-zA-Z_]\w*)',
              bygroups(Operator, Name.Attribute)),
@@ -945,6 +943,15 @@ class HybrisLexer(RegexLexer):
         ],
     }
 
+    def analyse_text(text):
+        """public method and private method don't seem to be quite common
+        elsewhere."""
+        result = 0
+        if re.search(r'\b(?:public|private)\s+method\b', text):
+            result += 0.01
+        return result
+
+
 
 class EasytrieveLexer(RegexLexer):
     """
@@ -977,7 +984,7 @@ class EasytrieveLexer(RegexLexer):
     _DELIMITER_PATTERN = '[' + _DELIMITERS + ']'
     _DELIMITER_PATTERN_CAPTURE = '(' + _DELIMITER_PATTERN + ')'
     _NON_DELIMITER_OR_COMMENT_PATTERN = '[^' + _DELIMITERS_OR_COMENT + ']'
-    _OPERATORS_PATTERN = u'[.+\\-/=\\[\\](){}<>;,&%¬]'
+    _OPERATORS_PATTERN = '[.+\\-/=\\[\\](){}<>;,&%¬]'
     _KEYWORDS = [
         'AFTER-BREAK', 'AFTER-LINE', 'AFTER-SCREEN', 'AIM', 'AND', 'ATTR',
         'BEFORE', 'BEFORE-BREAK', 'BEFORE-LINE', 'BEFORE-SCREEN', 'BUSHU',
@@ -1220,3 +1227,57 @@ class JclLexer(RegexLexer):
                 result = 1.0
         assert 0.0 <= result <= 1.0
         return result
+
+
+class MiniScriptLexer(RegexLexer):
+    """
+    For `MiniScript <https://miniscript.org>`_ source code.
+
+    .. versionadded:: 2.6
+    """
+
+    name = "MiniScript"
+    aliases = ["ms", "miniscript"]
+    filenames = ["*.ms"]
+    mimetypes = ['text/x-minicript', 'application/x-miniscript']
+
+    tokens = {
+        'root': [
+            (r'#!(.*?)$', Comment.Preproc),
+            default('base'),
+        ],
+        'base': [
+            ('//.*$', Comment.Single),
+            (r'(?i)(\d*\.\d+|\d+\.\d*)(e[+-]?\d+)?', Number),
+            (r'(?i)\d+e[+-]?\d+', Number),
+            (r'\d+', Number),
+            (r'\n', Text),
+            (r'[^\S\n]+', Text),
+            (r'"', String, 'string_double'),
+            (r'(==|!=|<=|>=|[=+\-*/%^<>.:])', Operator),
+            (r'[;,\[\]{}()]', Punctuation),
+            (words((
+                'break', 'continue', 'else', 'end', 'for', 'function', 'if',
+                'in', 'isa', 'then', 'repeat', 'return', 'while'), suffix=r'\b'),
+             Keyword),
+            (words((
+                'abs', 'acos', 'asin', 'atan', 'ceil', 'char', 'cos', 'floor',
+                'log', 'round', 'rnd', 'pi', 'sign', 'sin', 'sqrt', 'str', 'tan',
+                'hasIndex', 'indexOf', 'len', 'val', 'code', 'remove', 'lower',
+                'upper', 'replace', 'split', 'indexes', 'values', 'join', 'sum',
+                'sort', 'shuffle', 'push', 'pop', 'pull', 'range',
+                'print', 'input', 'time', 'wait', 'locals', 'globals', 'outer',
+                'yield'), suffix=r'\b'),
+             Name.Builtin),
+            (r'(true|false|null)\b', Keyword.Constant),
+            (r'(and|or|not|new)\b', Operator.Word),
+            (r'(self|super|__isa)\b', Name.Builtin.Pseudo),
+            (r'[a-zA-Z_]\w*', Name.Variable)
+        ],
+        'string_double': [
+            (r'[^"\n]+', String),
+            (r'""', String),
+            (r'"', String, '#pop'),
+            (r'\n', Text, '#pop'),  # Stray linefeed also terminates strings.
+        ]
+    }