pygments.rb 0.2.8 → 0.2.9

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

@@ -0,0 +1,330 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.github
+    ~~~~~~~~~~~~~~~~~~~
+
+    Custom lexers for GitHub.com
+
+    :copyright: Copyright 2012 by GitHub, Inc
+    :license: BSD, see LICENSE for details.
+"""
+import re
+
+from pygments.lexer import RegexLexer, include, bygroups, using, DelegatingLexer
+from pygments.token import Text, Name, Number, String, Comment, Punctuation, \
+     Other, Keyword, Operator, Literal
+
+__all__ = ['Dasm16Lexer', 'PuppetLexer', 'AugeasLexer']
+
+class Dasm16Lexer(RegexLexer):
+    """
+    Simple lexer for DCPU-16 Assembly
+
+    Check http://0x10c.com/doc/dcpu-16.txt
+    """
+    name = 'dasm16'
+    aliases = ['DASM16']
+    filenames = ['*.dasm16', '*.dasm']
+    mimetypes = ['text/x-dasm16']
+
+    INSTRUCTIONS = [
+        'SET', 'ADD', 'SUB', 'MUL', 'DIV', 'MOD', 'SHL',
+        'SHR', 'AND', 'BOR', 'XOR', 'IFE', 'IFN', 'IFG'
+        'IFB', 'JSR'
+    ]
+
+    REGISTERS = [
+        'A', 'B', 'C',
+        'X', 'Y', 'Z',
+        'I', 'J',
+        'SP', 'PC',
+        'POP', 'PEEK', 'PUSH'
+    ]
+
+    # Regexes yo
+    char = r'[a-zA-Z$._0-9@]'
+    identifier = r'(?:[a-zA-Z$_]' + char + '*|\.' + char + '+)'
+    number = r'(?:0[xX][a-zA-Z0-9]+|\d+)'
+    instruction = r'(?i)(' + '|'.join(INSTRUCTIONS) + ')'
+
+    def guess_identifier(lexer, match):
+        ident = match.group(0)
+        klass = Name.Variable if ident in lexer.REGISTERS else Name.Label
+        yield match.start(), klass, ident
+
+    tokens = {
+        'root': [
+            include('whitespace'),
+            (':' + identifier, Name.Label),
+            (instruction, Name.Function, 'instruction-args'),
+            (r'[\r\n]+', Text)
+        ],
+
+        'arg' : [
+            (identifier, guess_identifier),
+            (number, Number.Integer),
+        ],
+
+        'deref' : [
+            (r'\+', Punctuation),
+            (r'\]', Punctuation, '#pop'),
+            include('arg'),
+            include('whitespace')
+        ],
+
+        'instruction-args': [
+            (r',', Punctuation),
+            (r'\[', Punctuation, 'deref'),
+            include('arg'),
+
+            (r'[\r\n]+', Text, '#pop'),
+            (r';.*?$', Comment, '#pop'),
+            include('whitespace')
+        ],
+        'whitespace': [
+            (r'\n', Text),
+            (r'\s+', Text),
+            (r';.*?\n', Comment)
+        ],
+    }
+
+class PuppetLexer(RegexLexer):
+    name = 'Puppet'
+    aliases = ['puppet']
+    filenames = ['*.pp']
+
+    tokens = {
+        'root': [
+            include('puppet'),
+        ],
+        'puppet': [
+            include('comments'),
+            (r'(class|define)', Keyword.Declaration, ('block','class_name')),
+            (r'node', Keyword.Declaration, ('block', 'node_name')),
+            (r'elsif', Keyword.Reserved, ('block', 'conditional')),
+            (r'if', Keyword.Reserved, ('block', 'conditional')),
+            (r'unless', Keyword.Reserved, ('block', 'conditional')),
+            (r'(else)(\s*)(\{)', bygroups(Keyword.Reserved, Text, Punctuation), 'block'),
+            (r'case', Keyword.Reserved, ('case', 'conditional')),
+            (r'(::)?([A-Z][\w:]+)+(\s*)(<{1,2}\|)', bygroups(Name.Class, Name.Class, Text, Punctuation), 'spaceinvader'),
+            (r'(::)?([A-Z][\w:]+)+(\s*)(\{)', bygroups(Name.Class, Name.Class, Text, Punctuation), 'type'),
+            (r'(::)?([A-Z][\w:]+)+(\s*)(\[)', bygroups(Name.Class, Name.Class, Text, Punctuation), ('type', 'override_name')),
+            (r'(@{0,2}[\w:]+)(\s*)(\{)(\s*)', bygroups(Name.Class, Text, Punctuation, Text), ('type', 'namevar')),
+            (r'\$(::)?(\w+::)*\w+', Name.Variable, 'var_assign'),
+            (r'include', Keyword.Namespace, 'include'),
+            (r'import', Keyword.Namespace, 'import'),
+            (r'(\w+)(\()', bygroups(Name.Function, Punctuation), 'function'),
+            (r'\s', Text),
+        ],
+        'block': [
+            include('puppet'),
+            (r'\}', Text, '#pop'),
+        ],
+        'override_name': [
+            include('strings'),
+            include('variables'),
+            (r'\]', Punctuation),
+            (r'\s', Text),
+            (r'\{', Punctuation, '#pop'),
+        ],
+        'node_name': [
+            (r'inherits', Keyword.Declaration),
+            (r'[\w\.]+', String),
+            include('strings'),
+            include('variables'),
+            (r',', Punctuation),
+            (r'\s', Text),
+            (r'\{', Punctuation, '#pop'),
+        ],
+        'class_name': [
+            (r'inherits', Keyword.Declaration),
+            (r'[\w:]+', Name.Class),
+            (r'\s', Text),
+            (r'\{', Punctuation, '#pop'),
+            (r'\(', Punctuation, 'paramlist'),
+        ],
+        'include': [
+            (r'\n', Text, '#pop'),
+            (r'[\w:]+', Name.Class),
+            include('value'),
+            (r'\s', Text),
+        ],
+        'import': [
+            (r'\n', Text, '#pop'),
+            (r'[\/\w\.]+', String),
+            include('value'),
+            (r'\s', Text),
+        ],
+        'case': [
+            (r'(default)(:)(\s*)(\{)', bygroups(Keyword.Reserved, Punctuation, Text, Punctuation), 'block'),
+            include('case_values'),
+            (r'(:)(\s*)(\{)', bygroups(Punctuation, Text, Punctuation), 'block'),
+            (r'\s', Text),
+            (r'\}', Punctuation, '#pop'),
+        ],
+        'case_values': [
+            include('value'),
+            (r',', Punctuation),
+        ],
+        'comments': [
+            (r'\s*#.*\n', Comment.Singleline),
+        ],
+        'strings': [
+            (r"'.*?'", String.Single),
+            (r'\w+', String.Symbol),
+            (r'"', String.Double, 'dblstring'),
+            (r'\/.+?\/', String.Regex),
+        ],
+        'dblstring': [
+            (r'\$\{.+?\}', String.Interpol),
+            (r'(?:\\(?:[bdefnrstv\'"\$\\/]|[0-7][0-7]?[0-7]?|\^[a-zA-Z]))', String.Escape),
+            (r'[^"\\\$]+', String.Double),
+            (r'\$', String.Double),
+            (r'"', String.Double, '#pop'),
+        ],
+        'variables': [
+            (r'\$(::)?(\w+::)*\w+', Name.Variable),
+        ],
+        'var_assign': [
+            (r'\[', Punctuation, ('#pop', 'array')),
+            (r'\{', Punctuation, ('#pop', 'hash')),
+            (r'(\s*)(=)(\s*)', bygroups(Text, Operator, Text)),
+            (r'(\(|\))', Punctuation),
+            include('operators'),
+            include('value'),
+            (r'\s', Text, '#pop'),
+        ],
+        'booleans': [
+            (r'(true|false)', Literal),
+        ],
+        'operators': [
+            (r'(\s*)(==|=~|\*|-|\+|<<|>>|!=|!~|!|>=|<=|<|>|and|or|in)(\s*)', bygroups(Text, Operator, Text)),
+        ],
+        'conditional': [
+            include('operators'),
+            include('strings'),
+            include('variables'),
+            (r'\[', Punctuation, 'array'),
+            (r'\(', Punctuation, 'conditional'),
+            (r'\{', Punctuation, '#pop'),
+            (r'\)', Punctuation, '#pop'),
+            (r'\s', Text),
+        ],
+        'spaceinvader': [
+            include('operators'),
+            include('strings'),
+            include('variables'),
+            (r'\[', Punctuation, 'array'),
+            (r'\(', Punctuation, 'conditional'),
+            (r'\s', Text),
+            (r'\|>{1,2}', Punctuation, '#pop'),
+        ],
+        'namevar': [
+            include('value'),
+            (r'\[', Punctuation, 'array'),
+            (r'\s', Text),
+            (r':', Punctuation, '#pop'),
+            (r'\}', Punctuation, '#pop'),
+        ],
+        'function': [
+            (r'\[', Punctuation, 'array'),
+            include('value'),
+            (r',', Punctuation),
+            (r'\s', Text),
+            (r'\)', Punctuation, '#pop'),
+        ],
+        'paramlist': [
+            include('value'),
+            (r'=', Punctuation),
+            (r',', Punctuation),
+            (r'\s', Text),
+            (r'\[', Punctuation, 'array'),
+            (r'\)', Punctuation, '#pop'),
+        ],
+        'type': [
+            (r'(\w+)(\s*)(=>)(\s*)', bygroups(Name.Tag, Text, Punctuation, Text), 'param_value'),
+            (r'\}', Punctuation, '#pop'),
+            (r'\s', Text),
+            include('comments'),
+            (r'', Text, 'namevar'),
+        ],
+        'value': [
+            (r'[\d\.]', Number),
+            (r'([A-Z][\w:]+)+(\[)', bygroups(Name.Class, Punctuation), 'array'),
+            (r'(\w+)(\()', bygroups(Name.Function, Punctuation), 'function'),
+            include('strings'),
+            include('variables'),
+            include('comments'),
+            include('booleans'),
+            (r'(\s*)(\?)(\s*)(\{)', bygroups(Text, Punctuation, Text, Punctuation), 'selector'),
+            (r'\{', Punctuation, 'hash'),
+        ],
+        'selector': [
+            (r'default', Keyword.Reserved),
+            include('value'),
+            (r'=>', Punctuation),
+            (r',', Punctuation),
+            (r'\s', Text),
+            (r'\}', Punctuation, '#pop'),
+        ],
+        'param_value': [
+            include('value'),
+            (r'\[', Punctuation, 'array'),
+            (r',', Punctuation, '#pop'),
+            (r';', Punctuation, '#pop'),
+            (r'\s', Text, '#pop'),
+            (r'', Text, '#pop'),
+        ],
+        'array': [
+            include('value'),
+            (r'\[', Punctuation, 'array'),
+            (r',', Punctuation),
+            (r'\s', Text),
+            (r'\]', Punctuation, '#pop'),
+        ],
+        'hash': [
+            include('value'),
+            (r'\s', Text),
+            (r'=>', Punctuation),
+            (r',', Punctuation),
+            (r'\}', Punctuation, '#pop'),
+        ],
+    }
+
+class AugeasLexer(RegexLexer):
+    name = 'Augeas'
+    aliases = ['augeas']
+    filenames = ['*.aug']
+
+    tokens = {
+        'root': [
+            (r'(module)(\s*)([^\s=]+)', bygroups(Keyword.Namespace, Text, Name.Namespace)),
+            (r'(let)(\s*)([^\s=]+)', bygroups(Keyword.Declaration, Text, Name.Variable)),
+            (r'(del|store|value|counter|seq|key|label|autoload|incl|excl|transform|test|get|put)(\s+)', bygroups(Name.Builtin, Text)),
+            (r'(\()([^\:]+)(\:)(unit|string|regexp|lens|tree|filter)(\))', bygroups(Punctuation, Name.Variable, Punctuation, Keyword.Type, Punctuation)),
+            (r'\(\*', Comment.Multiline, 'comment'),
+            (r'[\+=\|\.\*\;\?-]', Operator),
+            (r'[\[\]\(\)\{\}]', Operator),
+            (r'"', String.Double, 'string'),
+            (r'\/', String.Regex, 'regex'),
+            (r'([A-Z]\w*)(\.)(\w+)', bygroups(Name.Namespace, Punctuation, Name.Variable)),
+            (r'.', Name.Variable),
+            (r'\s', Text),
+        ],
+        'string': [
+            (r'\\.', String.Escape),
+            (r'[^"]', String.Double),
+            (r'"', String.Double, '#pop'),
+        ],
+        'regex': [
+            (r'\\.', String.Escape),
+            (r'[^\/]', String.Regex),
+            (r'\/', String.Regex, '#pop'),
+        ],
+        'comment': [
+            (r'[^*\)]', Comment.Multiline),
+            (r'\(\*', Comment.Multiline, '#push'),
+            (r'\*\)', Comment.Multiline, '#pop'),
+            (r'[\*\)]', Comment.Multiline)
+        ],
+    }

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

@@ -11,15 +11,170 @@
 
 import re
 
-from pygments.lexer import Lexer, RegexLexer, bygroups, include, do_insertions
+from pygments.lexer import Lexer, RegexLexer, bygroups, include, \
+    combined, do_insertions
 from pygments.token import Comment, String, Punctuation, Keyword, Name, \
     Operator, Number, Text, Generic
 
 from pygments.lexers.agile import PythonLexer
 from pygments.lexers import _scilab_builtins
 
-__all__ = ['MuPADLexer', 'MatlabLexer', 'MatlabSessionLexer', 'OctaveLexer',
-           'ScilabLexer', 'NumPyLexer', 'RConsoleLexer', 'SLexer']
+__all__ = ['JuliaLexer', 'JuliaConsoleLexer', 'MuPADLexer', 'MatlabLexer',
+           'MatlabSessionLexer', 'OctaveLexer', 'ScilabLexer', 'NumPyLexer',
+           'RConsoleLexer', 'SLexer']
+
+
+class JuliaLexer(RegexLexer):
+    name = 'Julia'
+    aliases = ['julia','jl']
+    filenames = ['*.jl']
+    mimetypes = ['text/x-julia','application/x-julia']
+
+    builtins = [
+        'exit','whos','edit','load','is','isa','isequal','typeof','tuple',
+        'ntuple','uid','hash','finalizer','convert','promote','subtype',
+        'typemin','typemax','realmin','realmax','sizeof','eps','promote_type',
+        'method_exists','applicable','invoke','dlopen','dlsym','system',
+        'error','throw','assert','new','Inf','Nan','pi','im',
+    ]
+
+    tokens = {
+        'root': [
+            (r'\n', Text),
+            (r'[^\S\n]+', Text),
+            (r'#.*$', Comment),
+            (r'[]{}:(),;[@]', Punctuation),
+            (r'\\\n', Text),
+            (r'\\', Text),
+
+            # keywords
+            (r'(begin|while|for|in|return|break|continue|'
+             r'macro|quote|let|if|elseif|else|try|catch|end|'
+             r'bitstype|ccall)\b', Keyword),
+            (r'(local|global|const)\b', Keyword.Declaration),
+            (r'(module|import|export)\b', Keyword.Reserved),
+            (r'(Bool|Int|Int8|Int16|Int32|Int64|Uint|Uint8|Uint16|Uint32|Uint64'
+             r'|Float32|Float64|Complex64|Complex128|Any|Nothing|None)\b',
+                Keyword.Type),
+
+            # functions
+            (r'(function)((?:\s|\\\s)+)',
+                bygroups(Keyword,Name.Function), 'funcname'),
+
+            # types
+            (r'(type|typealias|abstract)((?:\s|\\\s)+)',
+                bygroups(Keyword,Name.Class), 'typename'),
+
+            # operators
+            (r'==|!=|<=|>=|->|&&|\|\||::|<:|[-~+/*%=<>&^|.?!$]', Operator),
+            (r'\.\*|\.\^|\.\\|\.\/|\\', Operator),
+
+            # builtins
+            ('(' + '|'.join(builtins) + r')\b',  Name.Builtin),
+
+            # backticks
+            (r'`(?s).*?`', String.Backtick),
+
+            # chars
+            (r"'(\\.|\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,3}|\\u[a-fA-F0-9]{1,4}|\\U[a-fA-F0-9]{1,6}|[^\\\'\n])'", String.Char),
+
+            # try to match trailing transpose
+            (r'(?<=[.\w\)\]])\'', Operator),
+
+            # strings
+            (r'(?:[IL])"', String, 'string'),
+            (r'[E]?"', String, combined('stringescape', 'string')),
+
+            # names
+            (r'@[a-zA-Z0-9_.]+', Name.Decorator),
+            (r'[a-zA-Z_][a-zA-Z0-9_]*', Name),
+
+            # numbers
+            (r'(\d+\.\d*|\d*\.\d+)([eE][+-]?[0-9]+)?', Number.Float),
+            (r'\d+[eE][+-]?[0-9]+', Number.Float),
+            (r'0[0-7]+', Number.Oct),
+            (r'0[xX][a-fA-F0-9]+', Number.Hex),
+            (r'\d+', Number.Integer)
+        ],
+
+        'funcname': [
+            ('[a-zA-Z_][a-zA-Z0-9_]*', Name.Function, '#pop'),
+            ('\([^\s\w{]{1,2}\)', Operator, '#pop'),
+            ('[^\s\w{]{1,2}', Operator, '#pop'),
+        ],
+
+        'typename': [
+            ('[a-zA-Z_][a-zA-Z0-9_]*', Name.Class, '#pop')
+        ],
+
+        'stringescape': [
+            (r'\\([\\abfnrtv"\']|\n|N{.*?}|u[a-fA-F0-9]{4}|'
+             r'U[a-fA-F0-9]{8}|x[a-fA-F0-9]{2}|[0-7]{1,3})', String.Escape)
+        ],
+
+        'string': [
+            (r'"', String, '#pop'),
+            (r'\\\\|\\"|\\\n', String.Escape), # included here for raw strings
+            (r'\$(\([a-zA-Z0-9_]+\))?[-#0 +]*([0-9]+|[*])?(\.([0-9]+|[*]))?',
+                String.Interpol),
+            (r'[^\\"$]+', String),
+            # quotes, dollar signs, and backslashes must be parsed one at a time
+            (r'["\\]', String),
+            # unhandled string formatting sign
+            (r'\$', String)
+        ],
+    }
+
+    def analyse_text(text):
+        return shebang_matches(text, r'julia')
+
+
+line_re  = re.compile('.*?\n')
+
+class JuliaConsoleLexer(Lexer):
+    """
+    For Julia console sessions. Modeled after MatlabSessionLexer.
+    """
+    name = 'Julia console'
+    aliases = ['jlcon']
+
+    def get_tokens_unprocessed(self, text):
+        jllexer = JuliaLexer(**self.options)
+
+        curcode = ''
+        insertions = []
+
+        for match in line_re.finditer(text):
+            line = match.group()
+
+            if line.startswith('julia>'):
+                insertions.append((len(curcode),
+                                   [(0, Generic.Prompt, line[:3])]))
+                curcode += line[3:]
+
+            elif line.startswith('      '):
+
+                idx = len(curcode)
+
+                # without is showing error on same line as before...?
+                line = "\n" + line
+                token = (0, Generic.Traceback, line)
+                insertions.append((idx, [token]))
+
+            else:
+                if curcode:
+                    for item in do_insertions(
+                        insertions, jllexer.get_tokens_unprocessed(curcode)):
+                        yield item
+                    curcode = ''
+                    insertions = []
+
+                yield match.start(), Generic.Output, line
+
+        if curcode: # or item:
+            for item in do_insertions(
+                insertions, jllexer.get_tokens_unprocessed(curcode)):
+                yield item
 
 
 class MuPADLexer(RegexLexer):