pygments.rb 1.2.1 → 2.2.0

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

@@ -0,0 +1,100 @@
+"""
+    pygments.lexers.go
+    ~~~~~~~~~~~~~~~~~~
+
+    Lexers for the Google Go language.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, bygroups, words
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation
+
+__all__ = ['GoLexer']
+
+
+class GoLexer(RegexLexer):
+    """
+    For `Go <http://golang.org>`_ source.
+
+    .. versionadded:: 1.2
+    """
+    name = 'Go'
+    filenames = ['*.go']
+    aliases = ['go']
+    mimetypes = ['text/x-gosrc']
+
+    flags = re.MULTILINE | re.UNICODE
+
+    tokens = {
+        'root': [
+            (r'\n', Text),
+            (r'\s+', Text),
+            (r'\\\n', Text),  # line continuations
+            (r'//(.*?)\n', Comment.Single),
+            (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
+            (r'(import|package)\b', Keyword.Namespace),
+            (r'(var|func|struct|map|chan|type|interface|const)\b',
+             Keyword.Declaration),
+            (words((
+                'break', 'default', 'select', 'case', 'defer', 'go',
+                'else', 'goto', 'switch', 'fallthrough', 'if', 'range',
+                'continue', 'for', 'return'), suffix=r'\b'),
+             Keyword),
+            (r'(true|false|iota|nil)\b', Keyword.Constant),
+            # It seems the builtin types aren't actually keywords, but
+            # can be used as functions. So we need two declarations.
+            (words((
+                'uint', 'uint8', 'uint16', 'uint32', 'uint64',
+                'int', 'int8', 'int16', 'int32', 'int64',
+                'float', 'float32', 'float64',
+                'complex64', 'complex128', 'byte', 'rune',
+                'string', 'bool', 'error', 'uintptr',
+                'print', 'println', 'panic', 'recover', 'close', 'complex',
+                'real', 'imag', 'len', 'cap', 'append', 'copy', 'delete',
+                'new', 'make'), suffix=r'\b(\()'),
+             bygroups(Name.Builtin, Punctuation)),
+            (words((
+                'uint', 'uint8', 'uint16', 'uint32', 'uint64',
+                'int', 'int8', 'int16', 'int32', 'int64',
+                'float', 'float32', 'float64',
+                'complex64', 'complex128', 'byte', 'rune',
+                'string', 'bool', 'error', 'uintptr'), suffix=r'\b'),
+             Keyword.Type),
+            # imaginary_lit
+            (r'\d+i', Number),
+            (r'\d+\.\d*([Ee][-+]\d+)?i', Number),
+            (r'\.\d+([Ee][-+]\d+)?i', Number),
+            (r'\d+[Ee][-+]\d+i', Number),
+            # float_lit
+            (r'\d+(\.\d+[eE][+\-]?\d+|'
+             r'\.\d*|[eE][+\-]?\d+)', Number.Float),
+            (r'\.\d+([eE][+\-]?\d+)?', Number.Float),
+            # int_lit
+            # -- octal_lit
+            (r'0[0-7]+', Number.Oct),
+            # -- hex_lit
+            (r'0[xX][0-9a-fA-F]+', Number.Hex),
+            # -- decimal_lit
+            (r'(0|[1-9][0-9]*)', Number.Integer),
+            # char_lit
+            (r"""'(\\['"\\abfnrtv]|\\x[0-9a-fA-F]{2}|\\[0-7]{1,3}"""
+             r"""|\\u[0-9a-fA-F]{4}|\\U[0-9a-fA-F]{8}|[^\\])'""",
+             String.Char),
+            # StringLiteral
+            # -- raw_string_lit
+            (r'`[^`]*`', String),
+            # -- interpreted_string_lit
+            (r'"(\\\\|\\[^\\]|[^"\\])*"', String),
+            # Tokens
+            (r'(<<=|>>=|<<|>>|<=|>=|&\^=|&\^|\+=|-=|\*=|/=|%=|&=|\|=|&&|\|\|'
+             r'|<-|\+\+|--|==|!=|:=|\.\.\.|[+\-*/%&])', Operator),
+            (r'[|^<>=!()\[\]{}.,;:]', Punctuation),
+            # identifier
+            (r'[^\W\d]\w*', Name.Other),
+        ]
+    }

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

@@ -0,0 +1,269 @@
+"""
+    pygments.lexers.grammar_notation
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for grammar notations like BNF.
+
+    :copyright: Copyright 2006-2021 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer, bygroups, include, this, using, words
+from pygments.token import Comment, Keyword, Literal, Name, Number, \
+    Operator, Punctuation, String, Text
+
+__all__ = ['BnfLexer', 'AbnfLexer', 'JsgfLexer', 'PegLexer']
+
+
+class BnfLexer(RegexLexer):
+    """
+    This lexer is for grammar notations which are similar to
+    original BNF.
+
+    In order to maximize a number of targets of this lexer,
+    let's decide some designs:
+
+    * We don't distinguish `Terminal Symbol`.
+
+    * We do assume that `NonTerminal Symbol` are always enclosed
+      with arrow brackets.
+
+    * We do assume that `NonTerminal Symbol` may include
+      any printable characters except arrow brackets and ASCII 0x20.
+      This assumption is for `RBNF <http://www.rfc-base.org/txt/rfc-5511.txt>`_.
+
+    * We do assume that target notation doesn't support comment.
+
+    * We don't distinguish any operators and punctuation except
+      `::=`.
+
+    Though these desision making might cause too minimal highlighting
+    and you might be disappointed, but it is reasonable for us.
+
+    .. versionadded:: 2.1
+    """
+
+    name = 'BNF'
+    aliases = ['bnf']
+    filenames = ['*.bnf']
+    mimetypes = ['text/x-bnf']
+
+    tokens = {
+        'root': [
+            (r'(<)([ -;=?-~]+)(>)',
+             bygroups(Punctuation, Name.Class, Punctuation)),
+
+            # an only operator
+            (r'::=', Operator),
+
+            # fallback
+            (r'[^<>:]+', Text),  # for performance
+            (r'.', Text),
+        ],
+    }
+
+
+class AbnfLexer(RegexLexer):
+    """
+    Lexer for `IETF 7405 ABNF
+    <http://www.ietf.org/rfc/rfc7405.txt>`_
+    (Updates `5234 <http://www.ietf.org/rfc/rfc5234.txt>`_)
+    grammars.
+
+    .. versionadded:: 2.1
+    """
+
+    name = 'ABNF'
+    aliases = ['abnf']
+    filenames = ['*.abnf']
+    mimetypes = ['text/x-abnf']
+
+    _core_rules = (
+        'ALPHA', 'BIT', 'CHAR', 'CR', 'CRLF', 'CTL', 'DIGIT',
+        'DQUOTE', 'HEXDIG', 'HTAB', 'LF', 'LWSP', 'OCTET',
+        'SP', 'VCHAR', 'WSP')
+
+    tokens = {
+        'root': [
+            # comment
+            (r';.*$', Comment.Single),
+
+            # quoted
+            #   double quote itself in this state, it is as '%x22'.
+            (r'(%[si])?"[^"]*"', Literal),
+
+            # binary (but i have never seen...)
+            (r'%b[01]+\-[01]+\b', Literal),  # range
+            (r'%b[01]+(\.[01]+)*\b', Literal),  # concat
+
+            # decimal
+            (r'%d[0-9]+\-[0-9]+\b', Literal),  # range
+            (r'%d[0-9]+(\.[0-9]+)*\b', Literal),  # concat
+
+            # hexadecimal
+            (r'%x[0-9a-fA-F]+\-[0-9a-fA-F]+\b', Literal),  # range
+            (r'%x[0-9a-fA-F]+(\.[0-9a-fA-F]+)*\b', Literal),  # concat
+
+            # repetition (<a>*<b>element) including nRule
+            (r'\b[0-9]+\*[0-9]+', Operator),
+            (r'\b[0-9]+\*', Operator),
+            (r'\b[0-9]+', Operator),
+            (r'\*', Operator),
+
+            # Strictly speaking, these are not keyword but
+            # are called `Core Rule'.
+            (words(_core_rules, suffix=r'\b'), Keyword),
+
+            # nonterminals (ALPHA *(ALPHA / DIGIT / "-"))
+            (r'[a-zA-Z][a-zA-Z0-9-]+\b', Name.Class),
+
+            # operators
+            (r'(=/|=|/)', Operator),
+
+            # punctuation
+            (r'[\[\]()]', Punctuation),
+
+            # fallback
+            (r'\s+', Text),
+            (r'.', Text),
+        ],
+    }
+
+
+class JsgfLexer(RegexLexer):
+    """
+    For `JSpeech Grammar Format <https://www.w3.org/TR/jsgf/>`_
+    grammars.
+
+    .. versionadded:: 2.2
+    """
+    name = 'JSGF'
+    aliases = ['jsgf']
+    filenames = ['*.jsgf']
+    mimetypes = ['application/jsgf', 'application/x-jsgf', 'text/jsgf']
+
+    flags = re.MULTILINE | re.UNICODE
+
+    tokens = {
+        'root': [
+            include('comments'),
+            include('non-comments'),
+        ],
+        'comments': [
+            (r'/\*\*(?!/)', Comment.Multiline, 'documentation comment'),
+            (r'/\*[\w\W]*?\*/', Comment.Multiline),
+            (r'//.*', Comment.Single),
+        ],
+        'non-comments': [
+            (r'\A#JSGF[^;]*', Comment.Preproc),
+            (r'\s+', Text),
+            (r';', Punctuation),
+            (r'[=|()\[\]*+]', Operator),
+            (r'/[^/]+/', Number.Float),
+            (r'"', String.Double, 'string'),
+            (r'\{', String.Other, 'tag'),
+            (words(('import', 'public'), suffix=r'\b'), Keyword.Reserved),
+            (r'grammar\b', Keyword.Reserved, 'grammar name'),
+            (r'(<)(NULL|VOID)(>)',
+             bygroups(Punctuation, Name.Builtin, Punctuation)),
+            (r'<', Punctuation, 'rulename'),
+            (r'\w+|[^\s;=|()\[\]*+/"{<\w]+', Text),
+        ],
+        'string': [
+            (r'"', String.Double, '#pop'),
+            (r'\\.', String.Escape),
+            (r'[^\\"]+', String.Double),
+        ],
+        'tag': [
+            (r'\}', String.Other, '#pop'),
+            (r'\\.', String.Escape),
+            (r'[^\\}]+', String.Other),
+        ],
+        'grammar name': [
+            (r';', Punctuation, '#pop'),
+            (r'\s+', Text),
+            (r'\.', Punctuation),
+            (r'[^;\s.]+', Name.Namespace),
+        ],
+        'rulename': [
+            (r'>', Punctuation, '#pop'),
+            (r'\*', Punctuation),
+            (r'\s+', Text),
+            (r'([^.>]+)(\s*)(\.)', bygroups(Name.Namespace, Text, Punctuation)),
+            (r'[^.>]+', Name.Constant),
+        ],
+        'documentation comment': [
+            (r'\*/', Comment.Multiline, '#pop'),
+            (r'(^\s*\*?\s*)(@(?:example|see)\s+)'
+             r'([\w\W]*?(?=(?:^\s*\*?\s*@|\*/)))',
+             bygroups(Comment.Multiline, Comment.Special,
+                      using(this, state='example'))),
+            (r'(^\s*\*?\s*)(@\S*)',
+             bygroups(Comment.Multiline, Comment.Special)),
+            (r'[^*\n@]+|\w|\W', Comment.Multiline),
+        ],
+        'example': [
+            (r'\n\s*\*', Comment.Multiline),
+            include('non-comments'),
+            (r'.', Comment.Multiline),
+        ],
+    }
+
+
+class PegLexer(RegexLexer):
+    """
+    This lexer is for `Parsing Expression Grammars
+    <https://bford.info/pub/lang/peg.pdf>`_ (PEG).
+
+    Various implementations of PEG have made different decisions
+    regarding the syntax, so let's try to be accommodating:
+
+    * `<-`, `←`, `:`, and `=` are all accepted as rule operators.
+
+    * Both `|` and `/` are choice operators.
+
+    * `^`, `↑`, and `~` are cut operators.
+
+    * A single `a-z` character immediately before a string, or
+      multiple `a-z` characters following a string, are part of the
+      string (e.g., `r"..."` or `"..."ilmsuxa`).
+
+    .. versionadded:: 2.6
+    """
+
+    name = 'PEG'
+    aliases = ['peg']
+    filenames = ['*.peg']
+    mimetypes = ['text/x-peg']
+
+    tokens = {
+        'root': [
+            # Comments
+            (r'#.*', Comment.Single),
+
+            # All operators
+            (r'<-|[←:=/|&!?*+^↑~]', Operator),
+
+            # Other punctuation
+            (r'[()]', Punctuation),
+
+            # Keywords
+            (r'\.', Keyword),
+
+            # Character classes
+            (r'(\[)([^\]]*(?:\\.[^\]\\]*)*)(\])',
+             bygroups(Punctuation, String, Punctuation)),
+
+            # Single and double quoted strings (with optional modifiers)
+            (r'[a-z]?"[^"\\]*(?:\\.[^"\\]*)*"[a-z]*', String.Double),
+            (r"[a-z]?'[^'\\]*(?:\\.[^'\\]*)*'[a-z]*", String.Single),
+
+            # Nonterminals are not whitespace, operators, or punctuation
+            (r'[^\s<←:=/|&!?*+\^↑~()\[\]"\'#]+', Name.Class),
+
+            # Fallback
+            (r'.', Text),
+        ],
+    }

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

@@ -0,0 +1,84 @@
+"""
+    pygments.lexers.graph
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for graph query languages.
+
+    :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 Keyword, Punctuation, Comment, Operator, Name,\
+    String, Number, Whitespace
+
+
+__all__ = ['CypherLexer']
+
+
+class CypherLexer(RegexLexer):
+    """
+    For `Cypher Query Language
+    <https://neo4j.com/docs/developer-manual/3.3/cypher/>`_
+
+    For the Cypher version in Neo4j 3.3
+
+    .. versionadded:: 2.0
+    """
+    name = 'Cypher'
+    aliases = ['cypher']
+    filenames = ['*.cyp', '*.cypher']
+
+    flags = re.MULTILINE | re.IGNORECASE
+
+    tokens = {
+        'root': [
+            include('comment'),
+            include('keywords'),
+            include('clauses'),
+            include('relations'),
+            include('strings'),
+            include('whitespace'),
+            include('barewords'),
+        ],
+        'comment': [
+            (r'^.*//.*\n', Comment.Single),
+        ],
+        'keywords': [
+            (r'(create|order|match|limit|set|skip|start|return|with|where|'
+             r'delete|foreach|not|by|true|false)\b', Keyword),
+        ],
+        'clauses': [
+            # based on https://neo4j.com/docs/cypher-refcard/3.3/
+            (r'(all|any|as|asc|ascending|assert|call|case|create|'
+             r'create\s+index|create\s+unique|delete|desc|descending|'
+             r'distinct|drop\s+constraint\s+on|drop\s+index\s+on|end|'
+             r'ends\s+with|fieldterminator|foreach|in|is\s+node\s+key|'
+             r'is\s+null|is\s+unique|limit|load\s+csv\s+from|match|merge|none|'
+             r'not|null|on\s+match|on\s+create|optional\s+match|order\s+by|'
+             r'remove|return|set|skip|single|start|starts\s+with|then|union|'
+             r'union\s+all|unwind|using\s+periodic\s+commit|yield|where|when|'
+             r'with)\b', Keyword),
+        ],
+        'relations': [
+            (r'(-\[)(.*?)(\]->)', bygroups(Operator, using(this), Operator)),
+            (r'(<-\[)(.*?)(\]-)', bygroups(Operator, using(this), Operator)),
+            (r'(-\[)(.*?)(\]-)', bygroups(Operator, using(this), Operator)),
+            (r'-->|<--|\[|\]', Operator),
+            (r'<|>|<>|=|<=|=>|\(|\)|\||:|,|;', Punctuation),
+            (r'[.*{}]', Punctuation),
+        ],
+        'strings': [
+            (r'"(?:\\[tbnrf\'"\\]|[^\\"])*"', String),
+            (r'`(?:``|[^`])+`', Name.Variable),
+        ],
+        'whitespace': [
+            (r'\s+', Whitespace),
+        ],
+        'barewords': [
+            (r'[a-z]\w*', Name),
+            (r'\d+', Number),
+        ],
+    }