pygments.rb 1.1.1 → 2.0.0.rc3

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

@@ -5,7 +5,7 @@
 
     Lexers for the Whiley language.
 
-    :copyright: Copyright 2006-2016 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -19,6 +19,8 @@ __all__ = ['WhileyLexer']
 class WhileyLexer(RegexLexer):
     """
     Lexer for the Whiley programming language.
+
+    .. versionadded:: 2.2
     """
     name = 'Whiley'
     filenames = ['*.whiley']
@@ -47,12 +49,10 @@ class WhileyLexer(RegexLexer):
                 'requires', 'ensures', 'where', 'assert', 'assume',
                 'all', 'no', 'some', 'in', 'is', 'new',
                 'throw', 'try', 'catch', 'debug', 'skip', 'fail',
-                'finite', 'total',
-             ), suffix=r'\b'), Keyword.Reserved),
+                'finite', 'total'), suffix=r'\b'), Keyword.Reserved),
             (words((
                 'function', 'method', 'public', 'private', 'protected',
-                'export', 'native',
-             ), suffix=r'\b'), Keyword.Declaration),
+                'export', 'native'), suffix=r'\b'), Keyword.Declaration),
             # "constant" & "type" are not keywords unless used in declarations
             (r'(constant|type)(\s+)([a-zA-Z_]\w*)(\s+)(is)\b',
              bygroups(Keyword.Declaration, Text, Name, Text, Keyword.Reserved)),
@@ -73,8 +73,7 @@ class WhileyLexer(RegexLexer):
                 'uint', 'nat',
 
                 # whiley.lang.Any
-                'toString',
-             ), suffix=r'\b'), Name.Builtin),
+                'toString'), suffix=r'\b'), Name.Builtin),
 
             # byte literal
             (r'[01]+b', Number.Bin),
@@ -98,11 +97,11 @@ class WhileyLexer(RegexLexer):
 
             # operators and punctuation
             (r'[{}()\[\],.;]', Punctuation),
-            (u'[+\\-*/%&|<>^!~@=:?'
-            # unicode operators
-             u'\u2200\u2203\u2205\u2282\u2286\u2283\u2287'
-             u'\u222A\u2229\u2264\u2265\u2208\u2227\u2228'
-             u']', Operator),
+            (r'[+\-*/%&|<>^!~@=:?'
+             # unicode operators
+             r'\u2200\u2203\u2205\u2282\u2286\u2283\u2287'
+             r'\u222A\u2229\u2264\u2265\u2208\u2227\u2228'
+             r']', Operator),
 
             # identifier
             (r'[a-zA-Z_]\w*', Name),

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

@@ -5,7 +5,7 @@
 
     Lexers for the X10 programming language.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 

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

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.xorg
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for Xorg configs.
+
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, bygroups
+from pygments.token import Comment, String, Name, Text
+
+__all__ = ['XorgLexer']
+
+
+class XorgLexer(RegexLexer):
+    """Lexer for xorg.conf file."""
+    name = 'Xorg'
+    aliases = ['xorg.conf']
+    filenames = ['xorg.conf']
+    mimetypes = []
+
+    tokens = {
+        'root': [
+            (r'\s+', Text),
+            (r'#.*$', Comment),
+
+            (r'((?:Sub)?Section)(\s+)("\w+")',
+             bygroups(String.Escape, Text, String.Escape)),
+            (r'(End(?:Sub)?Section)', String.Escape),
+
+            (r'(\w+)(\s+)([^\n#]+)',
+             bygroups(Name.Builtin, Text, Name.Constant)),
+        ],
+    }

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

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.yang
+    ~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for the YANG 1.1 modeling language. See :rfc:`7950`.
+
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import (RegexLexer, bygroups, words)
+from pygments.token import (Text, Token, Name, String, Comment,
+                            Number)
+
+__all__ = ['YangLexer']
+
+class YangLexer(RegexLexer):
+    """
+    Lexer for `YANG <https://tools.ietf.org/html/rfc7950/>`_, based on RFC7950
+
+    .. versionadded:: 2.7
+    """
+    name = 'YANG'
+    aliases = ['yang']
+    filenames = ['*.yang']
+    mimetypes = ['application/yang']
+
+    #Keywords from RFC7950 ; oriented at BNF style
+    TOP_STMTS_KEYWORDS = ("module", "submodule")
+    MODULE_HEADER_STMT_KEYWORDS = ("belongs-to", "namespace", "prefix", "yang-version")
+    META_STMT_KEYWORDS = ("contact", "description", "organization",
+                          "reference", "revision")
+    LINKAGE_STMTS_KEYWORDS = ("import", "include", "revision-date")
+    BODY_STMT_KEYWORDS = ("action", "argument", "augment", "deviation",
+                          "extension", "feature", "grouping", "identity",
+                          "if-feature", "input", "notification", "output",
+                          "rpc", "typedef")
+    DATA_DEF_STMT_KEYWORDS = ("anydata", "anyxml", "case", "choice",
+                              "config", "container", "deviate", "leaf",
+                              "leaf-list", "list", "must", "presence",
+                              "refine", "uses", "when")
+    TYPE_STMT_KEYWORDS = ("base", "bit", "default", "enum", "error-app-tag",
+                          "error-message", "fraction-digits", "length",
+                          "max-elements", "min-elements", "modifier",
+                          "ordered-by", "path", "pattern", "position",
+                          "range", "require-instance", "status", "type",
+                          "units", "value", "yin-element")
+    LIST_STMT_KEYWORDS = ("key", "mandatory", "unique")
+
+    #RFC7950 other keywords
+    CONSTANTS_KEYWORDS = ("add", "current", "delete", "deprecated", "false",
+                          "invert-match", "max", "min", "not-supported",
+                          "obsolete", "replace", "true", "unbounded", "user")
+
+    #RFC7950 Built-In Types
+    TYPES = ("binary", "bits", "boolean", "decimal64", "empty", "enumeration",
+             "identityref", "instance-identifier", "int16", "int32", "int64",
+             "int8", "leafref", "string", "uint16", "uint32", "uint64",
+             "uint8", "union")
+
+    suffix_re_pattern = r'(?=[^\w\-:])'
+
+    tokens = {
+        'comments': [
+            (r'[^*/]', Comment),
+            (r'/\*', Comment, '#push'),
+            (r'\*/', Comment, '#pop'),
+            (r'[*/]', Comment),
+        ],
+        "root": [
+            (r'\s+', Text.Whitespace),
+            (r'[{};]+', Token.Punctuation),
+            (r'(?<![\-\w])(and|or|not|\+|\.)(?![\-\w])', Token.Operator),
+
+            (r'"(?:\\"|[^"])*?"', String.Double),
+            (r"'(?:\\'|[^'])*?'", String.Single),
+
+            (r'/\*', Comment, 'comments'),
+            (r'//.*?$', Comment),
+
+            #match BNF stmt for `node-identifier` with [ prefix ":"]
+            (r'(?:^|(?<=[\s{};]))([\w.-]+)(:)([\w.-]+)(?=[\s{};])',
+             bygroups(Name.Namespace, Token.Punctuation, Name.Variable)),
+
+            #match BNF stmt `date-arg-str`
+            (r'([0-9]{4}\-[0-9]{2}\-[0-9]{2})(?=[\s{};])', Name.Label),
+            (r'([0-9]+\.[0-9]+)(?=[\s{};])', Number.Float),
+            (r'([0-9]+)(?=[\s{};])', Number.Integer),
+
+            (words(TOP_STMTS_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(MODULE_HEADER_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(META_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(LINKAGE_STMTS_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(BODY_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(DATA_DEF_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(TYPE_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(LIST_STMT_KEYWORDS, suffix=suffix_re_pattern), Token.Keyword),
+            (words(TYPES, suffix=suffix_re_pattern), Name.Class),
+            (words(CONSTANTS_KEYWORDS, suffix=suffix_re_pattern), Name.Class),
+
+            (r'[^;{}\s\'"]+', Name.Variable),
+        ]
+    }

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

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.zig
+    ~~~~~~~~~~~~~~~~~~~
+
+    Lexers for Zig.
+
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, words
+from pygments.token import Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Whitespace
+
+__all__ = ['ZigLexer']
+
+
+class ZigLexer(RegexLexer):
+    """
+    For `Zig <http://www.ziglang.org>`_ source code.
+
+    grammar: https://ziglang.org/documentation/master/#Grammar
+    """
+    name = 'Zig'
+    aliases = ['zig']
+    filenames = ['*.zig']
+    mimetypes = ['text/zig']
+
+    type_keywords = (
+        words(('bool', 'f16', 'f32', 'f64', 'f128', 'void', 'noreturn', 'type',
+               'anyerror', 'promise', 'i0', 'u0', 'isize',  'usize', 'comptime_int',
+               'comptime_float', 'c_short', 'c_ushort', 'c_int', 'c_uint', 'c_long',
+               'c_ulong', 'c_longlong', 'c_ulonglong', 'c_longdouble', 'c_void'
+               'i8', 'u8', 'i16', 'u16', 'i32', 'u32', 'i64', 'u64', 'i128',
+               'u128'), suffix=r'\b'),
+        Keyword.Type)
+
+    storage_keywords = (
+        words(('const', 'var', 'extern', 'packed', 'export', 'pub', 'noalias',
+               'inline', 'comptime', 'nakedcc', 'stdcallcc', 'volatile', 'allowzero',
+               'align', 'linksection', 'threadlocal'), suffix=r'\b'),
+        Keyword.Reserved)
+
+    structure_keywords = (
+        words(('struct', 'enum', 'union', 'error'), suffix=r'\b'),
+        Keyword)
+
+    statement_keywords = (
+        words(('break', 'return', 'continue', 'asm', 'defer', 'errdefer',
+               'unreachable', 'try', 'catch', 'async', 'await', 'suspend',
+               'resume', 'cancel'), suffix=r'\b'),
+        Keyword)
+
+    conditional_keywords = (
+        words(('if', 'else', 'switch', 'and', 'or', 'orelse'), suffix=r'\b'),
+        Keyword)
+
+    repeat_keywords = (
+        words(('while', 'for'), suffix=r'\b'),
+        Keyword)
+
+    other_keywords = (
+        words(('fn', 'usingnamespace', 'test'), suffix=r'\b'),
+        Keyword)
+
+    constant_keywords = (
+        words(('true', 'false', 'null', 'undefined'), suffix=r'\b'),
+        Keyword.Constant)
+
+    tokens = {
+        'root': [
+            (r'\n', Whitespace),
+            (r'\s+', Whitespace),
+            (r'//.*?\n', Comment.Single),
+
+            # Keywords
+            statement_keywords,
+            storage_keywords,
+            structure_keywords,
+            repeat_keywords,
+            type_keywords,
+            constant_keywords,
+            conditional_keywords,
+            other_keywords,
+
+            # Floats
+            (r'0x[0-9a-fA-F]+\.[0-9a-fA-F]+([pP][\-+]?[0-9a-fA-F]+)?', Number.Float),
+            (r'0x[0-9a-fA-F]+\.?[pP][\-+]?[0-9a-fA-F]+', Number.Float),
+            (r'[0-9]+\.[0-9]+([eE][-+]?[0-9]+)?', Number.Float),
+            (r'[0-9]+\.?[eE][-+]?[0-9]+', Number.Float),
+
+            # Integers
+            (r'0b[01]+', Number.Bin),
+            (r'0o[0-7]+', Number.Oct),
+            (r'0x[0-9a-fA-F]+', Number.Hex),
+            (r'[0-9]+', Number.Integer),
+
+            # Identifier
+            (r'@[a-zA-Z_]\w*', Name.Builtin),
+            (r'[a-zA-Z_]\w*', Name),
+
+            # Characters
+            (r'\'\\\'\'', String.Escape),
+            (r'\'\\(x[a-fA-F0-9]{2}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{6}|[nr\\t\'"])\'',
+             String.Escape),
+            (r'\'[^\\\']\'', String),
+
+            # Strings
+            (r'\\\\[^\n]*', String.Heredoc),
+            (r'c\\\\[^\n]*', String.Heredoc),
+            (r'c?"', String, 'string'),
+
+            # Operators, Punctuation
+            (r'[+%=><|^!?/\-*&~:]', Operator),
+            (r'[{}()\[\],.;]', Punctuation)
+        ],
+        'string': [
+            (r'\\(x[a-fA-F0-9]{2}|u[a-fA-F0-9]{4}|U[a-fA-F0-9]{6}|[nr\\t\'"])',
+             String.Escape),
+            (r'[^\\"\n]+', String),
+            (r'"', String, '#pop')
+        ]
+    }

data/vendor/pygments-main/pygments/modeline.py

@@ -5,7 +5,7 @@
 
     A simple modeline parser (based on pymodeline).
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -35,9 +35,10 @@ def get_filetype_from_buffer(buf, max_lines=5):
         ret = get_filetype_from_line(l)
         if ret:
             return ret
-    for l in lines[max_lines:-1:-1]:
-        ret = get_filetype_from_line(l)
-        if ret:
-            return ret
+    for i in range(max_lines, -1, -1):
+        if i < len(lines):
+            ret = get_filetype_from_line(lines[i])
+            if ret:
+                return ret
 
     return None

data/vendor/pygments-main/pygments/plugin.py

@@ -32,43 +32,39 @@
         yourfilter = yourfilter:YourFilter
 
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
-try:
-    import pkg_resources
-except ImportError:
-    pkg_resources = None
-
 LEXER_ENTRY_POINT = 'pygments.lexers'
 FORMATTER_ENTRY_POINT = 'pygments.formatters'
 STYLE_ENTRY_POINT = 'pygments.styles'
 FILTER_ENTRY_POINT = 'pygments.filters'
 
 
+def iter_entry_points(group_name):
+    try:
+        import pkg_resources
+    except (ImportError, IOError):
+        return []
+
+    return pkg_resources.iter_entry_points(group_name)
+
+
 def find_plugin_lexers():
-    if pkg_resources is None:
-        return
-    for entrypoint in pkg_resources.iter_entry_points(LEXER_ENTRY_POINT):
+    for entrypoint in iter_entry_points(LEXER_ENTRY_POINT):
         yield entrypoint.load()
 
 
 def find_plugin_formatters():
-    if pkg_resources is None:
-        return
-    for entrypoint in pkg_resources.iter_entry_points(FORMATTER_ENTRY_POINT):
+    for entrypoint in iter_entry_points(FORMATTER_ENTRY_POINT):
         yield entrypoint.name, entrypoint.load()
 
 
 def find_plugin_styles():
-    if pkg_resources is None:
-        return
-    for entrypoint in pkg_resources.iter_entry_points(STYLE_ENTRY_POINT):
+    for entrypoint in iter_entry_points(STYLE_ENTRY_POINT):
         yield entrypoint.name, entrypoint.load()
 
 
 def find_plugin_filters():
-    if pkg_resources is None:
-        return
-    for entrypoint in pkg_resources.iter_entry_points(FILTER_ENTRY_POINT):
+    for entrypoint in iter_entry_points(FILTER_ENTRY_POINT):
         yield entrypoint.name, entrypoint.load()

data/vendor/pygments-main/pygments/regexopt.py

@@ -6,7 +6,7 @@
     An algorithm that generates optimized regexes for matching long lists of
     literal strings.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 

data/vendor/pygments-main/pygments/scanner.py

@@ -12,7 +12,7 @@
     Have a look at the `DelphiLexer` to get an idea of how to use
     this scanner.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 import re
@@ -25,7 +25,7 @@ class EndOfText(RuntimeError):
     """
 
 
-class Scanner(object):
+class Scanner:
     """
     Simple scanner
 

data/vendor/pygments-main/pygments/sphinxext.py

@@ -6,17 +6,15 @@
     Sphinx extension to generate automatic documentation of lexers,
     formatters and filters.
 
-    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
-from __future__ import print_function
-
 import sys
 
 from docutils import nodes
 from docutils.statemachine import ViewList
-from sphinx.util.compat import Directive
+from docutils.parsers.rst import Directive
 from sphinx.util.nodes import nested_parse_with_titles