pygments.rb 0.6.3 → 1.0.0

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

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.capnproto
+    ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the Cap'n Proto schema language.
+
+    :copyright: Copyright 2006-2015 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, Literal
+
+__all__ = ['CapnProtoLexer']
+
+
+class CapnProtoLexer(RegexLexer):
+    """
+    For `Cap'n Proto <https://capnproto.org>`_ source.
+
+    .. versionadded:: 2.2
+    """
+    name = 'Cap\'n Proto'
+    filenames = ['*.capnp']
+    aliases = ['capnp']
+
+    flags = re.MULTILINE | re.UNICODE
+
+
+    tokens = {
+        'root': [
+            (r'#.*?$', Comment.Single),
+            (r'@[0-9a-zA-Z]*', Name.Decorator),
+            (r'=', Literal, 'expression'),
+            (r':', Name.Class, 'type'),
+            (r'\$', Name.Attribute, 'annotation'),
+            (r'(struct|enum|interface|union|import|using|const|annotation|extends|in|of|on|as|with|from|fixed)\b',
+                Keyword),
+            (r'[a-zA-Z0-9_.]+', Name),
+            (r'[^#@=:$a-zA-Z0-9_]+', Text),
+        ],
+        'type': [
+            (r'[^][=;,(){}$]+', Name.Class),
+            (r'[[(]', Name.Class, 'parentype'),
+            (r'', Name.Class, '#pop')
+        ],
+        'parentype': [
+            (r'[^][;()]+', Name.Class),
+            (r'[[(]', Name.Class, '#push'),
+            (r'[])]', Name.Class, '#pop'),
+            (r'', Name.Class, '#pop')
+        ],
+        'expression': [
+            (r'[^][;,(){}$]+', Literal),
+            (r'[[(]', Literal, 'parenexp'),
+            (r'', Literal, '#pop')
+        ],
+        'parenexp': [
+            (r'[^][;()]+', Literal),
+            (r'[[(]', Literal, '#push'),
+            (r'[])]', Literal, '#pop'),
+            (r'', Literal, '#pop')
+        ],
+        'annotation': [
+            (r'[^][;,(){}=:]+', Name.Attribute),
+            (r'[[(]', Name.Attribute, 'annexp'),
+            (r'', Name.Attribute, '#pop')
+        ],
+        'annexp': [
+            (r'[^][;()]+', Name.Attribute),
+            (r'[[(]', Name.Attribute, '#push'),
+            (r'[])]', Name.Attribute, '#pop'),
+            (r'', Name.Attribute, '#pop')
+        ],
+    }

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

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.chapel
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for the Chapel language.
+
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, bygroups, words
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation
+
+__all__ = ['ChapelLexer']
+
+
+class ChapelLexer(RegexLexer):
+    """
+    For `Chapel <http://chapel.cray.com/>`_ source.
+
+    .. versionadded:: 2.0
+    """
+    name = 'Chapel'
+    filenames = ['*.chpl']
+    aliases = ['chapel', 'chpl']
+    # mimetypes = ['text/x-chapel']
+
+    tokens = {
+        'root': [
+            (r'\n', Text),
+            (r'\s+', Text),
+            (r'\\\n', Text),
+
+            (r'//(.*?)\n', Comment.Single),
+            (r'/(\\\n)?[*](.|\n)*?[*](\\\n)?/', Comment.Multiline),
+
+            (r'(config|const|in|inout|out|param|ref|type|var)\b',
+             Keyword.Declaration),
+            (r'(false|nil|true)\b', Keyword.Constant),
+            (r'(bool|complex|imag|int|opaque|range|real|string|uint)\b',
+             Keyword.Type),
+            (words((
+                'align', 'as', 'atomic', 'begin', 'break', 'by', 'cobegin',
+                'coforall', 'continue', 'delete', 'dmapped', 'do', 'domain',
+                'else', 'enum', 'except', 'export', 'extern', 'for', 'forall',
+                'if', 'index', 'inline', 'iter', 'label', 'lambda', 'let',
+                'local', 'new', 'noinit', 'on', 'only', 'otherwise', 'pragma',
+                'private', 'public', 'reduce', 'require', 'return', 'scan',
+                'select', 'serial', 'single', 'sparse', 'subdomain', 'sync',
+                'then', 'use', 'when', 'where', 'while', 'with', 'yield',
+                'zip'), suffix=r'\b'),
+             Keyword),
+            (r'(proc)((?:\s|\\\s)+)', bygroups(Keyword, Text), 'procname'),
+            (r'(class|module|record|union)(\s+)', bygroups(Keyword, Text),
+             'classname'),
+
+            # imaginary integers
+            (r'\d+i', Number),
+            (r'\d+\.\d*([Ee][-+]\d+)?i', Number),
+            (r'\.\d+([Ee][-+]\d+)?i', Number),
+            (r'\d+[Ee][-+]\d+i', Number),
+
+            # reals cannot end with a period due to lexical ambiguity with
+            # .. operator. See reference for rationale.
+            (r'(\d*\.\d+)([eE][+-]?[0-9]+)?i?', Number.Float),
+            (r'\d+[eE][+-]?[0-9]+i?', Number.Float),
+
+            # integer literals
+            # -- binary
+            (r'0[bB][01]+', Number.Bin),
+            # -- hex
+            (r'0[xX][0-9a-fA-F]+', Number.Hex),
+            # -- octal
+            (r'0[oO][0-7]+', Number.Oct),
+            # -- decimal
+            (r'[0-9]+', Number.Integer),
+
+            # strings
+            (r'"(\\\\|\\"|[^"])*"', String),
+            (r"'(\\\\|\\'|[^'])*'", String),
+
+            # tokens
+            (r'(=|\+=|-=|\*=|/=|\*\*=|%=|&=|\|=|\^=|&&=|\|\|=|<<=|>>=|'
+             r'<=>|<~>|\.\.|by|#|\.\.\.|'
+             r'&&|\|\||!|&|\||\^|~|<<|>>|'
+             r'==|!=|<=|>=|<|>|'
+             r'[+\-*/%]|\*\*)', Operator),
+            (r'[:;,.?()\[\]{}]', Punctuation),
+
+            # identifiers
+            (r'[a-zA-Z_][\w$]*', Name.Other),
+        ],
+        'classname': [
+            (r'[a-zA-Z_][\w$]*', Name.Class, '#pop'),
+        ],
+        'procname': [
+            (r'[a-zA-Z_][\w$]*', Name.Function, '#pop'),
+        ],
+    }

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

@@ -0,0 +1,288 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.clean
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Lexer for the Clean language.
+
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import ExtendedRegexLexer, LexerContext, \
+    bygroups, words, include, default
+from pygments.token import Comment, Keyword, Literal, Name, Number, Operator, \
+    Punctuation, String, Text, Whitespace
+
+__all__ = ['CleanLexer']
+
+
+class CleanLexer(ExtendedRegexLexer):
+    """
+    Lexer for the general purpose, state-of-the-art, pure and lazy functional
+    programming language Clean (http://clean.cs.ru.nl/Clean).
+
+    .. versionadded: 2.2
+    """
+    name = 'Clean'
+    aliases = ['clean']
+    filenames = ['*.icl', '*.dcl']
+
+    def get_tokens_unprocessed(self, text=None, context=None):
+        ctx = LexerContext(text, 0)
+        ctx.indent = 0
+        return ExtendedRegexLexer.get_tokens_unprocessed(self, text, context=ctx)
+
+    def check_class_not_import(lexer, match, ctx):
+        if match.group(0) == 'import':
+            yield match.start(), Keyword.Namespace, match.group(0)
+            ctx.stack = ctx.stack[:-1] + ['fromimportfunc']
+        else:
+            yield match.start(), Name.Class, match.group(0)
+        ctx.pos = match.end()
+
+    def check_instance_class(lexer, match, ctx):
+        if match.group(0) == 'instance' or match.group(0) == 'class':
+            yield match.start(), Keyword, match.group(0)
+        else:
+            yield match.start(), Name.Function, match.group(0)
+            ctx.stack = ctx.stack + ['fromimportfunctype']
+        ctx.pos = match.end()
+
+    @staticmethod
+    def indent_len(text):
+        # Tabs are four spaces:
+        # https://svn.cs.ru.nl/repos/clean-platform/trunk/doc/STANDARDS.txt
+        text = text.replace('\n', '')
+        return len(text.replace('\t', '    ')), len(text)
+
+    def store_indent(lexer, match, ctx):
+        ctx.indent, _ = CleanLexer.indent_len(match.group(0))
+        ctx.pos = match.end()
+        yield match.start(), Text, match.group(0)
+
+    def check_indent1(lexer, match, ctx):
+        indent, reallen = CleanLexer.indent_len(match.group(0))
+        if indent > ctx.indent:
+            yield match.start(), Whitespace, match.group(0)
+            ctx.pos = match.start() + reallen + 1
+        else:
+            ctx.indent = 0
+            ctx.pos = match.start()
+            ctx.stack = ctx.stack[:-1]
+            yield match.start(), Whitespace, match.group(0)[1:]
+
+    def check_indent2(lexer, match, ctx):
+        indent, reallen = CleanLexer.indent_len(match.group(0))
+        if indent > ctx.indent:
+            yield match.start(), Whitespace, match.group(0)
+            ctx.pos = match.start() + reallen + 1
+        else:
+            ctx.indent = 0
+            ctx.pos = match.start()
+            ctx.stack = ctx.stack[:-2]
+
+    def check_indent3(lexer, match, ctx):
+        indent, reallen = CleanLexer.indent_len(match.group(0))
+        if indent > ctx.indent:
+            yield match.start(), Whitespace, match.group(0)
+            ctx.pos = match.start() + reallen + 1
+        else:
+            ctx.indent = 0
+            ctx.pos = match.start()
+            ctx.stack = ctx.stack[:-3]
+            yield match.start(), Whitespace, match.group(0)[1:]
+            if match.group(0) == '\n\n':
+                ctx.pos = ctx.pos + 1
+
+    def skip(lexer, match, ctx):
+        ctx.stack = ctx.stack[:-1]
+        ctx.pos = match.end()
+        yield match.start(), Comment, match.group(0)
+
+    keywords = ('class', 'instance', 'where', 'with', 'let', 'let!',
+                'in', 'case', 'of', 'infix', 'infixr', 'infixl', 'generic',
+                'derive', 'otherwise', 'code', 'inline')
+
+    tokens = {
+        'common': [
+            (r';', Punctuation, '#pop'),
+            (r'//', Comment, 'singlecomment'),
+        ],
+        'root': [
+            # Comments
+            (r'//.*\n', Comment.Single),
+            (r'(?s)/\*\*.*?\*/', Comment.Special),
+            (r'(?s)/\*.*?\*/', Comment.Multi),
+
+            # Modules, imports, etc.
+            (r'\b((?:implementation|definition|system)\s+)?(module)(\s+)([\w`\.]+)',
+                bygroups(Keyword.Namespace, Keyword.Namespace, Text, Name.Class)),
+            (r'(?<=\n)import(?=\s)', Keyword.Namespace, 'import'),
+            (r'(?<=\n)from(?=\s)', Keyword.Namespace, 'fromimport'),
+
+            # Keywords
+            # We cannot use (?s)^|(?<=\s) as prefix, so need to repeat this
+            (words(keywords, prefix=r'(?<=\s)', suffix=r'(?=\s)'), Keyword),
+            (words(keywords, prefix=r'^', suffix=r'(?=\s)'), Keyword),
+
+            # Function definitions
+            (r'(?=\{\|)', Whitespace, 'genericfunction'),
+            (r'(?<=\n)([ \t]*)([\w`$()=\-<>~*\^|+&%]+)((?:\s+\w)*)(\s*)(::)',
+             bygroups(store_indent, Name.Function, Keyword.Type, Whitespace,
+                      Punctuation),
+             'functiondefargs'),
+
+            # Type definitions
+            (r'(?<=\n)([ \t]*)(::)', bygroups(store_indent, Punctuation), 'typedef'),
+            (r'^([ \t]*)(::)', bygroups(store_indent, Punctuation), 'typedef'),
+
+            # Literals
+            (r'\'\\?.(?<!\\)\'', String.Char),
+            (r'\'\\\d+\'', String.Char),
+            (r'\'\\\\\'', String.Char), # (special case for '\\')
+            (r'[+\-~]?\s*\d+\.\d+(E[+\-~]?\d+)?\b', Number.Float),
+            (r'[+\-~]?\s*0[0-7]\b', Number.Oct),
+            (r'[+\-~]?\s*0x[0-9a-fA-F]\b', Number.Hex),
+            (r'[+\-~]?\s*\d+\b', Number.Integer),
+            (r'"', String.Double, 'doubleqstring'),
+            (words(('True', 'False'), prefix=r'(?<=\s)', suffix=r'(?=\s)'),
+             Literal),
+
+            # Qualified names
+            (r'(\')([\w\.]+)(\'\.)',
+                bygroups(Punctuation, Name.Namespace, Punctuation)),
+
+            # Everything else is some name
+            (r'([\w`$%\/\?@]+\.?)*[\w`$%\/\?@]+', Name),
+
+            # Punctuation
+            (r'[{}()\[\],:;.#]', Punctuation),
+            (r'[+\-=!<>|&~*\^/]', Operator),
+            (r'\\\\', Operator),
+
+            # Lambda expressions
+            (r'\\.*?(->|\.|=)', Name.Function),
+
+            # Whitespace
+            (r'\s', Whitespace),
+
+            include('common'),
+        ],
+        'fromimport': [
+            include('common'),
+            (r'([\w`\.]+)', check_class_not_import),
+            (r'\n', Whitespace, '#pop'),
+            (r'\s', Whitespace),
+        ],
+        'fromimportfunc': [
+            include('common'),
+            (r'(::)\s+([^,\s]+)', bygroups(Punctuation, Keyword.Type)),
+            (r'([\w`$()=\-<>~*\^|+&%\/]+)', check_instance_class),
+            (r',', Punctuation),
+            (r'\n', Whitespace, '#pop'),
+            (r'\s', Whitespace),
+        ],
+        'fromimportfunctype': [
+            include('common'),
+            (r'[{(\[]', Punctuation, 'combtype'),
+            (r',', Punctuation, '#pop'),
+            (r'[:;.#]', Punctuation),
+            (r'\n', Whitespace, '#pop:2'),
+            (r'[^\S\n]+', Whitespace),
+            (r'\S+', Keyword.Type),
+        ],
+        'combtype': [
+            include('common'),
+            (r'[})\]]', Punctuation, '#pop'),
+            (r'[{(\[]', Punctuation, '#pop'),
+            (r'[,:;.#]', Punctuation),
+            (r'\s+', Whitespace),
+            (r'\S+', Keyword.Type),
+        ],
+        'import': [
+            include('common'),
+            (words(('from', 'import', 'as', 'qualified'),
+                   prefix='(?<=\s)', suffix='(?=\s)'), Keyword.Namespace),
+            (r'[\w`\.]+', Name.Class),
+            (r'\n', Whitespace, '#pop'),
+            (r',', Punctuation),
+            (r'[^\S\n]+', Whitespace),
+        ],
+        'singlecomment': [
+            (r'(.)(?=\n)', skip),
+            (r'.+(?!\n)', Comment),
+        ],
+        'doubleqstring': [
+            (r'[^\\"]+', String.Double),
+            (r'"', String.Double, '#pop'),
+            (r'\\.', String.Double),
+        ],
+        'typedef': [
+            include('common'),
+            (r'[\w`]+', Keyword.Type),
+            (r'[:=|(),\[\]{}!*]', Punctuation),
+            (r'->', Punctuation),
+            (r'\n(?=[^\s|])', Whitespace, '#pop'),
+            (r'\s', Whitespace),
+            (r'.', Keyword.Type),
+        ],
+        'genericfunction': [
+            include('common'),
+            (r'\{\|', Punctuation),
+            (r'\|\}', Punctuation, '#pop'),
+            (r',', Punctuation),
+            (r'->', Punctuation),
+            (r'(\s+of\s+)(\{)', bygroups(Keyword, Punctuation), 'genericftypes'),
+            (r'\s', Whitespace),
+            (r'[\w`\[\]{}!]+', Keyword.Type),
+            (r'[*()]', Punctuation),
+        ],
+        'genericftypes': [
+            include('common'),
+            (r'[\w`]+', Keyword.Type),
+            (r',', Punctuation),
+            (r'\s', Whitespace),
+            (r'\}', Punctuation, '#pop'),
+        ],
+        'functiondefargs': [
+            include('common'),
+            (r'\n(\s*)', check_indent1),
+            (r'[!{}()\[\],:;.#]', Punctuation),
+            (r'->', Punctuation, 'functiondefres'),
+            (r'^(?=\S)', Whitespace, '#pop'),
+            (r'\S', Keyword.Type),
+            (r'\s', Whitespace),
+        ],
+        'functiondefres': [
+            include('common'),
+            (r'\n(\s*)', check_indent2),
+            (r'^(?=\S)', Whitespace, '#pop:2'),
+            (r'[!{}()\[\],:;.#]', Punctuation),
+            (r'\|', Punctuation, 'functiondefclasses'),
+            (r'\S', Keyword.Type),
+            (r'\s', Whitespace),
+        ],
+        'functiondefclasses': [
+            include('common'),
+            (r'\n(\s*)', check_indent3),
+            (r'^(?=\S)', Whitespace, '#pop:3'),
+            (r'[,&]', Punctuation),
+            (r'\[', Punctuation, 'functiondefuniquneq'),
+            (r'[\w`$()=\-<>~*\^|+&%\/{}\[\]@]', Name.Function, 'functionname'),
+            (r'\s+', Whitespace),
+        ],
+        'functiondefuniquneq': [
+            include('common'),
+            (r'[a-z]+', Keyword.Type),
+            (r'\s+', Whitespace),
+            (r'<=|,', Punctuation),
+            (r'\]', Punctuation, '#pop')
+        ],
+        'functionname': [
+            include('common'),
+            (r'[\w`$()=\-<>~*\^|+&%\/]+', Name.Function),
+            (r'(?=\{\|)', Punctuation, 'genericfunction'),
+            default('#pop'),
+        ]
+    }