pygmentize 0.0.1

data/vendor/pygments/plugin.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.plugin
+    ~~~~~~~~~~~~~~~
+
+    Pygments setuptools plugin interface. The methods defined
+    here also work if setuptools isn't installed but they just
+    return nothing.
+
+    lexer plugins::
+
+        [pygments.lexers]
+        yourlexer = yourmodule:YourLexer
+
+    formatter plugins::
+
+        [pygments.formatters]
+        yourformatter = yourformatter:YourFormatter
+        /.ext = yourformatter:YourFormatter
+
+    As you can see, you can define extensions for the formatter
+    with a leading slash.
+
+    syntax plugins::
+
+        [pygments.styles]
+        yourstyle = yourstyle:YourStyle
+
+    filter plugin::
+
+        [pygments.filter]
+        yourfilter = yourfilter:YourFilter
+
+
+    :copyright: Copyright 2006-2010 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 find_plugin_lexers():
+    if pkg_resources is None:
+        return
+    for entrypoint in pkg_resources.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):
+        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):
+        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):
+        yield entrypoint.name, entrypoint.load()

data/vendor/pygments/scanner.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.scanner
+    ~~~~~~~~~~~~~~~~
+
+    This library implements a regex based scanner. Some languages
+    like Pascal are easy to parse but have some keywords that
+    depend on the context. Because of this it's impossible to lex
+    that just by using a regular expression lexer like the
+    `RegexLexer`.
+
+    Have a look at the `DelphiLexer` to get an idea of how to use
+    this scanner.
+
+    :copyright: Copyright 2006-2010 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+import re
+
+
+class EndOfText(RuntimeError):
+    """
+    Raise if end of text is reached and the user
+    tried to call a match function.
+    """
+
+
+class Scanner(object):
+    """
+    Simple scanner
+
+    All method patterns are regular expression strings (not
+    compiled expressions!)
+    """
+
+    def __init__(self, text, flags=0):
+        """
+        :param text:    The text which should be scanned
+        :param flags:   default regular expression flags
+        """
+        self.data = text
+        self.data_length = len(text)
+        self.start_pos = 0
+        self.pos = 0
+        self.flags = flags
+        self.last = None
+        self.match = None
+        self._re_cache = {}
+
+    def eos(self):
+        """`True` if the scanner reached the end of text."""
+        return self.pos >= self.data_length
+    eos = property(eos, eos.__doc__)
+
+    def check(self, pattern):
+        """
+        Apply `pattern` on the current position and return
+        the match object. (Doesn't touch pos). Use this for
+        lookahead.
+        """
+        if self.eos:
+            raise EndOfText()
+        if pattern not in self._re_cache:
+            self._re_cache[pattern] = re.compile(pattern, self.flags)
+        return self._re_cache[pattern].match(self.data, self.pos)
+
+    def test(self, pattern):
+        """Apply a pattern on the current position and check
+        if it patches. Doesn't touch pos."""
+        return self.check(pattern) is not None
+
+    def scan(self, pattern):
+        """
+        Scan the text for the given pattern and update pos/match
+        and related fields. The return value is a boolen that
+        indicates if the pattern matched. The matched value is
+        stored on the instance as ``match``, the last value is
+        stored as ``last``. ``start_pos`` is the position of the
+        pointer before the pattern was matched, ``pos`` is the
+        end position.
+        """
+        if self.eos:
+            raise EndOfText()
+        if pattern not in self._re_cache:
+            self._re_cache[pattern] = re.compile(pattern, self.flags)
+        self.last = self.match
+        m = self._re_cache[pattern].match(self.data, self.pos)
+        if m is None:
+            return False
+        self.start_pos = m.start()
+        self.pos = m.end()
+        self.match = m.group()
+        return True
+
+    def get_char(self):
+        """Scan exactly one char."""
+        self.scan('.')
+
+    def __repr__(self):
+        return '<%s %d/%d>' % (
+            self.__class__.__name__,
+            self.pos,
+            self.data_length
+        )

data/vendor/pygments/style.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.style
+    ~~~~~~~~~~~~~~
+
+    Basic style object.
+
+    :copyright: Copyright 2006-2010 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.token import Token, STANDARD_TYPES
+
+
+class StyleMeta(type):
+
+    def __new__(mcs, name, bases, dct):
+        obj = type.__new__(mcs, name, bases, dct)
+        for token in STANDARD_TYPES:
+            if token not in obj.styles:
+                obj.styles[token] = ''
+
+        def colorformat(text):
+            if text[0:1] == '#':
+                col = text[1:]
+                if len(col) == 6:
+                    return col
+                elif len(col) == 3:
+                    return col[0]+'0'+col[1]+'0'+col[2]+'0'
+            elif text == '':
+                return ''
+            assert False, "wrong color format %r" % text
+
+        _styles = obj._styles = {}
+
+        for ttype in obj.styles:
+            for token in ttype.split():
+                if token in _styles:
+                    continue
+                ndef = _styles.get(token.parent, None)
+                styledefs = obj.styles.get(token, '').split()
+                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][:]
+                else:
+                    ndef = ndef[:]
+                _styles[token] = ndef
+                for styledef in obj.styles.get(token, '').split():
+                    if styledef == 'noinherit':
+                        pass
+                    elif styledef == 'bold':
+                        ndef[1] = 1
+                    elif styledef == 'nobold':
+                        ndef[1] = 0
+                    elif styledef == 'italic':
+                        ndef[2] = 1
+                    elif styledef == 'noitalic':
+                        ndef[2] = 0
+                    elif styledef == 'underline':
+                        ndef[3] = 1
+                    elif styledef == 'nounderline':
+                        ndef[3] = 0
+                    elif styledef[:3] == 'bg:':
+                        ndef[4] = colorformat(styledef[3:])
+                    elif styledef[:7] == 'border:':
+                        ndef[5] = colorformat(styledef[7:])
+                    elif styledef == 'roman':
+                        ndef[6] = 1
+                    elif styledef == 'sans':
+                        ndef[7] = 1
+                    elif styledef == 'mono':
+                        ndef[8] = 1
+                    else:
+                        ndef[0] = colorformat(styledef)
+
+        return obj
+
+    def style_for_token(cls, token):
+        t = cls._styles[token]
+        return {
+            'color':        t[0] or None,
+            'bold':         bool(t[1]),
+            'italic':       bool(t[2]),
+            'underline':    bool(t[3]),
+            'bgcolor':      t[4] 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,
+        }
+
+    def list_styles(cls):
+        return list(cls)
+
+    def styles_token(cls, ttype):
+        return ttype in cls._styles
+
+    def __iter__(cls):
+        for token in cls._styles:
+            yield token, cls.style_for_token(token)
+
+    def __len__(cls):
+        return len(cls._styles)
+
+
+class Style(object):
+    __metaclass__ = StyleMeta
+
+    #: overall background color (``None`` means transparent)
+    background_color = '#ffffff'
+
+    #: highlight background color
+    highlight_color = '#ffffcc'
+
+    #: Style definitions for individual token types.
+    styles = {}

data/vendor/pygments/styles/__init__.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.styles
+    ~~~~~~~~~~~~~~~
+
+    Contains built-in styles.
+
+    :copyright: Copyright 2006-2010 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.plugin import find_plugin_styles
+from pygments.util import ClassNotFound
+
+
+#: Maps style names to 'submodule::classname'.
+STYLE_MAP = {
+    'default':  'default::DefaultStyle',
+    'emacs':    'emacs::EmacsStyle',
+    'friendly': 'friendly::FriendlyStyle',
+    'colorful': 'colorful::ColorfulStyle',
+    'autumn':   'autumn::AutumnStyle',
+    'murphy':   'murphy::MurphyStyle',
+    'manni':    'manni::ManniStyle',
+    'monokai':  'monokai::MonokaiStyle',
+    'perldoc':  'perldoc::PerldocStyle',
+    'pastie':   'pastie::PastieStyle',
+    'borland':  'borland::BorlandStyle',
+    'trac':     'trac::TracStyle',
+    'native':   'native::NativeStyle',
+    'fruity':   'fruity::FruityStyle',
+    'bw':       'bw::BlackWhiteStyle',
+    'vs':       'vs::VisualStudioStyle',
+    'tango':    'tango::TangoStyle',
+}
+
+
+def get_style_by_name(name):
+    if name in STYLE_MAP:
+        mod, cls = STYLE_MAP[name].split('::')
+        builtin = "yes"
+    else:
+        for found_name, style in find_plugin_styles():
+            if name == found_name:
+                return style
+        # perhaps it got dropped into our styles package
+        builtin = ""
+        mod = name
+        cls = name.title() + "Style"
+
+    try:
+        mod = __import__('pygments.styles.' + mod, None, None, [cls])
+    except ImportError:
+        raise ClassNotFound("Could not find style module %r" % mod +
+                         (builtin and ", though it should be builtin") + ".")
+    try:
+        return getattr(mod, cls)
+    except AttributeError:
+        raise ClassNotFound("Could not find style class %r in style module." % cls)
+
+
+def get_all_styles():
+    """Return an generator for all styles by name,
+    both builtin and plugin."""
+    for name in STYLE_MAP:
+        yield name
+    for name, _ in find_plugin_styles():
+        yield name

data/vendor/pygments/styles/autumn.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.styles.autumn
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    A colorful style, inspired by the terminal highlighting style.
+
+    :copyright: Copyright 2006-2010 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.style import Style
+from pygments.token import Keyword, Name, Comment, String, Error, \
+     Number, Operator, Generic, Whitespace
+
+
+class AutumnStyle(Style):
+    """
+    A colorful style, inspired by the terminal highlighting style.
+    """
+
+    default_style = ""
+
+    styles = {
+        Whitespace:                 '#bbbbbb',
+
+        Comment:                    'italic #aaaaaa',
+        Comment.Preproc:            'noitalic #4c8317',
+        Comment.Special:            'italic #0000aa',
+
+        Keyword:                    '#0000aa',
+        Keyword.Type:               '#00aaaa',
+
+        Operator.Word:              '#0000aa',
+
+        Name.Builtin:               '#00aaaa',
+        Name.Function:              '#00aa00',
+        Name.Class:                 'underline #00aa00',
+        Name.Namespace:             'underline #00aaaa',
+        Name.Variable:              '#aa0000',
+        Name.Constant:              '#aa0000',
+        Name.Entity:                'bold #800',
+        Name.Attribute:             '#1e90ff',
+        Name.Tag:                   'bold #1e90ff',
+        Name.Decorator:             '#888888',
+
+        String:                     '#aa5500',
+        String.Symbol:              '#0000aa',
+        String.Regex:               '#009999',
+
+        Number:                     '#009999',
+
+        Generic.Heading:            'bold #000080',
+        Generic.Subheading:         'bold #800080',
+        Generic.Deleted:            '#aa0000',
+        Generic.Inserted:           '#00aa00',
+        Generic.Error:              '#aa0000',
+        Generic.Emph:               'italic',
+        Generic.Strong:             'bold',
+        Generic.Prompt:             '#555555',
+        Generic.Output:             '#888888',
+        Generic.Traceback:          '#aa0000',
+
+        Error:                      '#F00 bg:#FAA'
+    }

data/vendor/pygments/styles/borland.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.styles.borland
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Style similar to the style used in the Borland IDEs.
+
+    :copyright: Copyright 2006-2010 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.style import Style
+from pygments.token import Keyword, Name, Comment, String, Error, \
+     Number, Operator, Generic, Whitespace
+
+
+class BorlandStyle(Style):
+    """
+    Style similar to the style used in the borland IDEs.
+    """
+
+    default_style = ''
+
+    styles = {
+        Whitespace:             '#bbbbbb',
+
+        Comment:                'italic #008800',
+        Comment.Preproc:        'noitalic #008080',
+        Comment.Special:        'noitalic bold',
+
+        String:                 '#0000FF',
+        String.Char:            '#800080',
+        Number:                 '#0000FF',
+        Keyword:                'bold #000080',
+        Operator.Word:          'bold',
+        Name.Tag:               'bold #000080',
+        Name.Attribute:         '#FF0000',
+
+        Generic.Heading:        '#999999',
+        Generic.Subheading:     '#aaaaaa',
+        Generic.Deleted:        'bg:#ffdddd #000000',
+        Generic.Inserted:       'bg:#ddffdd #000000',
+        Generic.Error:          '#aa0000',
+        Generic.Emph:           'italic',
+        Generic.Strong:         'bold',
+        Generic.Prompt:         '#555555',
+        Generic.Output:         '#888888',
+        Generic.Traceback:      '#aa0000',
+
+        Error:                  'bg:#e3d2d2 #a61717'
+    }