pygments.rb 0.6.3 → 1.0.0

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

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.whiley
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the Whiley language.
+
+    :copyright: Copyright 2006-2016 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.lexer import RegexLexer, bygroups, words
+from pygments.token import Comment, Keyword, Name, Number, Operator, \
+    Punctuation, String, Text
+
+__all__ = ['WhileyLexer']
+
+
+class WhileyLexer(RegexLexer):
+    """
+    Lexer for the Whiley programming language.
+    """
+    name = 'Whiley'
+    filenames = ['*.whiley']
+    aliases = ['whiley']
+    mimetypes = ['text/x-whiley']
+
+    # See the language specification:
+    # http://whiley.org/download/WhileyLanguageSpec.pdf
+
+    tokens = {
+        'root': [
+            # Whitespace
+            (r'\s+', Text),
+
+            # Comments
+            (r'//.*', Comment.Single),
+            # don't parse empty comment as doc comment
+            (r'/\*\*/', Comment.Multiline),
+            (r'(?s)/\*\*.*?\*/', String.Doc),
+            (r'(?s)/\*.*?\*/', Comment.Multiline),
+
+            # Keywords
+            (words((
+                'if', 'else', 'while', 'for', 'do', 'return',
+                'switch', 'case', 'default', 'break', 'continue',
+                'requires', 'ensures', 'where', 'assert', 'assume',
+                'all', 'no', 'some', 'in', 'is', 'new',
+                'throw', 'try', 'catch', 'debug', 'skip', 'fail',
+                'finite', 'total',
+             ), suffix=r'\b'), Keyword.Reserved),
+            (words((
+                'function', 'method', 'public', 'private', 'protected',
+                '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)),
+            (r'(true|false|null)\b', Keyword.Constant),
+            (r'(bool|byte|int|real|any|void)\b', Keyword.Type),
+            # "from" is not a keyword unless used with import
+            (r'(import)(\s+)(\*)([^\S\n]+)(from)\b',
+             bygroups(Keyword.Namespace, Text, Punctuation, Text, Keyword.Namespace)),
+            (r'(import)(\s+)([a-zA-Z_]\w*)([^\S\n]+)(from)\b',
+             bygroups(Keyword.Namespace, Text, Name, Text, Keyword.Namespace)),
+            (r'(package|import)\b', Keyword.Namespace),
+
+            # standard library: https://github.com/Whiley/WhileyLibs/
+            (words((
+                # types defined in whiley.lang.Int
+                'i8', 'i16', 'i32', 'i64',
+                'u8', 'u16', 'u32', 'u64',
+                'uint', 'nat',
+
+                # whiley.lang.Any
+                'toString',
+             ), suffix=r'\b'), Name.Builtin),
+
+            # byte literal
+            (r'[01]+b', Number.Bin),
+
+            # decimal literal
+            (r'[0-9]+\.[0-9]+', Number.Float),
+            # match "1." but not ranges like "3..5"
+            (r'[0-9]+\.(?!\.)', Number.Float),
+
+            # integer literal
+            (r'0x[0-9a-fA-F]+', Number.Hex),
+            (r'[0-9]+', Number.Integer),
+
+            # character literal
+            (r"""'[^\\]'""", String.Char),
+            (r"""(')(\\['"\\btnfr])(')""",
+             bygroups(String.Char, String.Escape, String.Char)),
+
+            # string literal
+            (r'"', String, 'string'),
+
+            # 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),
+
+            # identifier
+            (r'[a-zA-Z_]\w*', Name),
+        ],
+        'string': [
+            (r'"', String, '#pop'),
+            (r'\\[btnfr]', String.Escape),
+            (r'\\u[0-9a-fA-F]{4}', String.Escape),
+            (r'\\.', String),
+            (r'[^\\"]+', String),
+        ],
+    }

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

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.lexers.x10
+    ~~~~~~~~~~~~~~~~~~~
+
+    Lexers for the X10 programming language.
+
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+
+from pygments.lexer import RegexLexer
+from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
+    Number, Punctuation, Error
+
+__all__ = ['X10Lexer']
+
+class X10Lexer(RegexLexer):
+    """
+    For the X10 language.
+
+    .. versionadded:: 0.1
+    """
+
+    name = 'X10'
+    aliases = ['x10', 'xten']
+    filenames = ['*.x10']
+    mimetypes = ['text/x-x10']
+
+    keywords = (
+        'as', 'assert', 'async', 'at', 'athome', 'ateach', 'atomic',
+        'break', 'case', 'catch', 'class', 'clocked', 'continue',
+        'def', 'default', 'do', 'else', 'final', 'finally', 'finish',
+        'for', 'goto', 'haszero', 'here', 'if', 'import', 'in',
+        'instanceof', 'interface', 'isref', 'new', 'offer',
+        'operator', 'package', 'return', 'struct', 'switch', 'throw',
+        'try', 'type', 'val', 'var', 'when', 'while'
+    )
+
+    types = (
+        'void'
+    )
+
+    values = (
+        'false', 'null', 'self', 'super', 'this', 'true'
+    )
+
+    modifiers = (
+        'abstract', 'extends', 'implements', 'native', 'offers',
+        'private', 'property', 'protected', 'public', 'static',
+        'throws', 'transient'
+    )
+
+    tokens = {
+        'root': [
+            (r'[^\S\n]+', Text),
+            (r'//.*?\n', Comment.Single),
+            (r'/\*(.|\n)*?\*/', Comment.Multiline),
+            (r'\b(%s)\b' % '|'.join(keywords), Keyword),
+            (r'\b(%s)\b' % '|'.join(types), Keyword.Type),
+            (r'\b(%s)\b' % '|'.join(values), Keyword.Constant),
+            (r'\b(%s)\b' % '|'.join(modifiers), Keyword.Declaration),
+            (r'"(\\\\|\\"|[^"])*"', String),
+            (r"'\\.'|'[^\\]'|'\\u[0-9a-fA-F]{4}'", String.Char),
+            (r'.', Text)
+        ],
+    }

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

@@ -5,7 +5,7 @@
 
     A simple modeline parser (based on pymodeline).
 
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -13,16 +13,19 @@ import re
 
 __all__ = ['get_filetype_from_buffer']
 
+
 modeline_re = re.compile(r'''
     (?: vi | vim | ex ) (?: [<=>]? \d* )? :
     .* (?: ft | filetype | syn | syntax ) = ( [^:\s]+ )
 ''', re.VERBOSE)
 
+
 def get_filetype_from_line(l):
     m = modeline_re.search(l)
     if m:
         return m.group(1)
 
+
 def get_filetype_from_buffer(buf, max_lines=5):
     """
     Scan the buffer for modelines and return filetype if one is found.
@@ -32,7 +35,7 @@ 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:0:-1]:
+    for l in lines[max_lines:-1:-1]:
         ret = get_filetype_from_line(l)
         if ret:
             return ret

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

@@ -32,7 +32,7 @@
         yourfilter = yourfilter:YourFilter
 
 
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 try:

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

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.regexopt
+    ~~~~~~~~~~~~~~~~~
+
+    An algorithm that generates optimized regexes for matching long lists of
+    literal strings.
+
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import re
+from re import escape
+from os.path import commonprefix
+from itertools import groupby
+from operator import itemgetter
+
+CS_ESCAPE = re.compile(r'[\^\\\-\]]')
+FIRST_ELEMENT = itemgetter(0)
+
+
+def make_charset(letters):
+    return '[' + CS_ESCAPE.sub(lambda m: '\\' + m.group(), ''.join(letters)) + ']'
+
+
+def regex_opt_inner(strings, open_paren):
+    """Return a regex that matches any string in the sorted list of strings."""
+    close_paren = open_paren and ')' or ''
+    # print strings, repr(open_paren)
+    if not strings:
+        # print '-> nothing left'
+        return ''
+    first = strings[0]
+    if len(strings) == 1:
+        # print '-> only 1 string'
+        return open_paren + escape(first) + close_paren
+    if not first:
+        # print '-> first string empty'
+        return open_paren + regex_opt_inner(strings[1:], '(?:') \
+            + '?' + close_paren
+    if len(first) == 1:
+        # multiple one-char strings? make a charset
+        oneletter = []
+        rest = []
+        for s in strings:
+            if len(s) == 1:
+                oneletter.append(s)
+            else:
+                rest.append(s)
+        if len(oneletter) > 1:  # do we have more than one oneletter string?
+            if rest:
+                # print '-> 1-character + rest'
+                return open_paren + regex_opt_inner(rest, '') + '|' \
+                    + make_charset(oneletter) + close_paren
+            # print '-> only 1-character'
+            return open_paren + make_charset(oneletter) + close_paren
+    prefix = commonprefix(strings)
+    if prefix:
+        plen = len(prefix)
+        # we have a prefix for all strings
+        # print '-> prefix:', prefix
+        return open_paren + escape(prefix) \
+            + regex_opt_inner([s[plen:] for s in strings], '(?:') \
+            + close_paren
+    # is there a suffix?
+    strings_rev = [s[::-1] for s in strings]
+    suffix = commonprefix(strings_rev)
+    if suffix:
+        slen = len(suffix)
+        # print '-> suffix:', suffix[::-1]
+        return open_paren \
+            + regex_opt_inner(sorted(s[:-slen] for s in strings), '(?:') \
+            + escape(suffix[::-1]) + close_paren
+    # recurse on common 1-string prefixes
+    # print '-> last resort'
+    return open_paren + \
+        '|'.join(regex_opt_inner(list(group[1]), '')
+                 for group in groupby(strings, lambda s: s[0] == first[0])) \
+        + close_paren
+
+
+def regex_opt(strings, prefix='', suffix=''):
+    """Return a compiled regex that matches any string in the given list.
+
+    The strings to match must be literal strings, not regexes.  They will be
+    regex-escaped.
+
+    *prefix* and *suffix* are pre- and appended to the final regex.
+    """
+    strings = sorted(strings)
+    return prefix + regex_opt_inner(strings, '(') + suffix

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-2014 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 import re
@@ -66,7 +66,8 @@ class Scanner(object):
 
     def test(self, pattern):
         """Apply a pattern on the current position and check
-        if it patches. Doesn't touch pos."""
+        if it patches. Doesn't touch pos.
+        """
         return self.check(pattern) is not None
 
     def scan(self, pattern):

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

@@ -6,7 +6,7 @@
     Sphinx extension to generate automatic documentation of lexers,
     formatters and filters.
 
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
@@ -57,6 +57,7 @@ FILTERDOC = '''
 
 '''
 
+
 class PygmentsDoc(Directive):
     """
     A directive to collect all lexers/formatters/filters and generate
@@ -113,6 +114,8 @@ class PygmentsDoc(Directive):
                 moduledocstrings[module] = moddoc
 
         for module, lexers in sorted(modules.items(), key=lambda x: x[0]):
+            if moduledocstrings[module] is None:
+                raise Exception("Missing docstring for %s" % (module,))
             heading = moduledocstrings[module].splitlines()[4].strip().rstrip('.')
             out.append(MODULEDOC % (module, heading, '-'*len(heading)))
             for data in lexers:
@@ -124,15 +127,17 @@ class PygmentsDoc(Directive):
         from pygments.formatters import FORMATTERS
 
         out = []
-        for cls, data in sorted(FORMATTERS.items(),
-                                key=lambda x: x[0].__name__):
-            self.filenames.add(sys.modules[cls.__module__].__file__)
+        for classname, data in sorted(FORMATTERS.items(), key=lambda x: x[0]):
+            module = data[0]
+            mod = __import__(module, None, None, [classname])
+            self.filenames.add(mod.__file__)
+            cls = getattr(mod, classname)
             docstring = cls.__doc__
             if isinstance(docstring, bytes):
                 docstring = docstring.decode('utf8')
             heading = cls.__name__
-            out.append(FMTERDOC % (heading, ', '.join(data[1]) or 'None',
-                                   ', '.join(data[2]).replace('*', '\\*') or 'None',
+            out.append(FMTERDOC % (heading, ', '.join(data[2]) or 'None',
+                                   ', '.join(data[3]).replace('*', '\\*') or 'None',
                                    docstring))
         return ''.join(out)
 

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

@@ -5,13 +5,36 @@
 
     Basic style object.
 
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2015 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 from pygments.token import Token, STANDARD_TYPES
 from pygments.util import add_metaclass
 
+# Default mapping of #ansixxx to RGB colors.
+_ansimap = {
+    # dark
+    '#ansiblack': '000000',
+    '#ansidarkred': '7f0000',
+    '#ansidarkgreen': '007f00',
+    '#ansibrown': '7f7fe0',
+    '#ansidarkblue': '00007f',
+    '#ansipurple': '7f007f',
+    '#ansiteal': '007f7f',
+    '#ansilightgray': 'e5e5e5',
+    # normal
+    '#ansidarkgray': '555555',
+    '#ansired': 'ff0000',
+    '#ansigreen': '00ff00',
+    '#ansiyellow': 'ffff00',
+    '#ansiblue': '0000ff',
+    '#ansifuchsia': 'ff00ff',
+    '#ansiturquoise': '00ffff',
+    '#ansiwhite': 'ffffff',
+}
+ansicolors = set(_ansimap)
+
 
 class StyleMeta(type):
 
@@ -22,6 +45,8 @@ class StyleMeta(type):
                 obj.styles[token] = ''
 
         def colorformat(text):
+            if text in ansicolors:
+                return text
             if text[0:1] == '#':
                 col = text[1:]
                 if len(col) == 6:
@@ -40,7 +65,7 @@ class StyleMeta(type):
                     continue
                 ndef = _styles.get(token.parent, None)
                 styledefs = obj.styles.get(token, '').split()
-                if  not ndef or token is None:
+                if not ndef or token is None:
                     ndef = ['', 0, 0, 0, '', '', 0, 0, 0]
                 elif 'noinherit' in styledefs and token is not Token:
                     ndef = _styles[Token][:]
@@ -79,16 +104,28 @@ class StyleMeta(type):
 
     def style_for_token(cls, token):
         t = cls._styles[token]
+        ansicolor = bgansicolor = None
+        color = t[0]
+        if color.startswith('#ansi'):
+            ansicolor = color
+            color = _ansimap[color]
+        bgcolor = t[4]
+        if bgcolor.startswith('#ansi'):
+            bgansicolor = bgcolor
+            bgcolor = _ansimap[bgcolor]
+
         return {
-            'color':        t[0] or None,
+            'color':        color or None,
             'bold':         bool(t[1]),
             'italic':       bool(t[2]),
             'underline':    bool(t[3]),
-            'bgcolor':      t[4] or None,
+            'bgcolor':      bgcolor or None,
             'border':       t[5] or None,
             'roman':        bool(t[6]) or None,
             'sans':         bool(t[7]) or None,
             'mono':         bool(t[8]) or None,
+            'ansicolor':    ansicolor,
+            'bgansicolor':  bgansicolor,
         }
 
     def list_styles(cls):