gitlab-pygments.rb 0.3.2

data/vendor/pygments-main/pygments/formatters/rtf.py

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.formatters.rtf
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    A formatter that generates RTF files.
+
+    :copyright: Copyright 2006-2012 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.formatter import Formatter
+
+
+__all__ = ['RtfFormatter']
+
+
+class RtfFormatter(Formatter):
+    """
+    Format tokens as RTF markup. This formatter automatically outputs full RTF
+    documents with color information and other useful stuff. Perfect for Copy and
+    Paste into Microsoft® Word® documents.
+
+    *New in Pygments 0.6.*
+
+    Additional options accepted:
+
+    `style`
+        The style to use, can be a string or a Style subclass (default:
+        ``'default'``).
+
+    `fontface`
+        The used font famliy, for example ``Bitstream Vera Sans``. Defaults to
+        some generic font which is supposed to have fixed width.
+    """
+    name = 'RTF'
+    aliases = ['rtf']
+    filenames = ['*.rtf']
+
+    unicodeoutput = False
+
+    def __init__(self, **options):
+        """
+        Additional options accepted:
+
+        ``fontface``
+            Name of the font used. Could for example be ``'Courier New'``
+            to further specify the default which is ``'\fmodern'``. The RTF
+            specification claims that ``\fmodern`` are "Fixed-pitch serif
+            and sans serif fonts". Hope every RTF implementation thinks
+            the same about modern...
+        """
+        Formatter.__init__(self, **options)
+        self.fontface = options.get('fontface') or ''
+
+    def _escape(self, text):
+        return text.replace('\\', '\\\\') \
+                   .replace('{', '\\{') \
+                   .replace('}', '\\}')
+
+    def _escape_text(self, text):
+        # empty strings, should give a small performance improvment
+        if not text:
+            return ''
+
+        # escape text
+        text = self._escape(text)
+        if self.encoding in ('utf-8', 'utf-16', 'utf-32'):
+            encoding = 'iso-8859-15'
+        else:
+            encoding = self.encoding or 'iso-8859-15'
+
+        buf = []
+        for c in text:
+            if ord(c) > 128:
+                ansic = c.encode(encoding, 'ignore') or '?'
+                if ord(ansic) > 128:
+                    ansic = '\\\'%x' % ord(ansic)
+                else:
+                    ansic = c
+                buf.append(r'\ud{\u%d%s}' % (ord(c), ansic))
+            else:
+                buf.append(str(c))
+
+        return ''.join(buf).replace('\n', '\\par\n')
+
+    def format_unencoded(self, tokensource, outfile):
+        # rtf 1.8 header
+        outfile.write(r'{\rtf1\ansi\deff0'
+                      r'{\fonttbl{\f0\fmodern\fprq1\fcharset0%s;}}'
+                      r'{\colortbl;' % (self.fontface and
+                                        ' ' + self._escape(self.fontface) or
+                                        ''))
+
+        # convert colors and save them in a mapping to access them later.
+        color_mapping = {}
+        offset = 1
+        for _, style in self.style:
+            for color in style['color'], style['bgcolor'], style['border']:
+                if color and color not in color_mapping:
+                    color_mapping[color] = offset
+                    outfile.write(r'\red%d\green%d\blue%d;' % (
+                        int(color[0:2], 16),
+                        int(color[2:4], 16),
+                        int(color[4:6], 16)
+                    ))
+                    offset += 1
+        outfile.write(r'}\f0')
+
+        # highlight stream
+        for ttype, value in tokensource:
+            while not self.style.styles_token(ttype) and ttype.parent:
+                ttype = ttype.parent
+            style = self.style.style_for_token(ttype)
+            buf = []
+            if style['bgcolor']:
+                buf.append(r'\cb%d' % color_mapping[style['bgcolor']])
+            if style['color']:
+                buf.append(r'\cf%d' % color_mapping[style['color']])
+            if style['bold']:
+                buf.append(r'\b')
+            if style['italic']:
+                buf.append(r'\i')
+            if style['underline']:
+                buf.append(r'\ul')
+            if style['border']:
+                buf.append(r'\chbrdr\chcfpat%d' %
+                           color_mapping[style['border']])
+            start = ''.join(buf)
+            if start:
+                outfile.write('{%s ' % start)
+            outfile.write(self._escape_text(value))
+            if start:
+                outfile.write('}')
+
+        outfile.write('}')

data/vendor/pygments-main/pygments/formatters/svg.py

@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.formatters.svg
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Formatter for SVG output.
+
+    :copyright: Copyright 2006-2012 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.formatter import Formatter
+from pygments.util import get_bool_opt, get_int_opt
+
+__all__ = ['SvgFormatter']
+
+
+def escape_html(text):
+    """Escape &, <, > as well as single and double quotes for HTML."""
+    return text.replace('&', '&amp;').  \
+                replace('<', '&lt;').   \
+                replace('>', '&gt;').   \
+                replace('"', '&quot;'). \
+                replace("'", '&#39;')
+
+
+class2style = {}
+
+class SvgFormatter(Formatter):
+    """
+    Format tokens as an SVG graphics file.  This formatter is still experimental.
+    Each line of code is a ``<text>`` element with explicit ``x`` and ``y``
+    coordinates containing ``<tspan>`` elements with the individual token styles.
+
+    By default, this formatter outputs a full SVG document including doctype
+    declaration and the ``<svg>`` root element.
+
+    *New in Pygments 0.9.*
+
+    Additional options accepted:
+
+    `nowrap`
+        Don't wrap the SVG ``<text>`` elements in ``<svg><g>`` elements and
+        don't add a XML declaration and a doctype.  If true, the `fontfamily`
+        and `fontsize` options are ignored.  Defaults to ``False``.
+
+    `fontfamily`
+        The value to give the wrapping ``<g>`` element's ``font-family``
+        attribute, defaults to ``"monospace"``.
+
+    `fontsize`
+        The value to give the wrapping ``<g>`` element's ``font-size``
+        attribute, defaults to ``"14px"``.
+
+    `xoffset`
+        Starting offset in X direction, defaults to ``0``.
+
+    `yoffset`
+        Starting offset in Y direction, defaults to the font size if it is given
+        in pixels, or ``20`` else.  (This is necessary since text coordinates
+        refer to the text baseline, not the top edge.)
+
+    `ystep`
+        Offset to add to the Y coordinate for each subsequent line.  This should
+        roughly be the text size plus 5.  It defaults to that value if the text
+        size is given in pixels, or ``25`` else.
+
+    `spacehack`
+        Convert spaces in the source to ``&#160;``, which are non-breaking
+        spaces.  SVG provides the ``xml:space`` attribute to control how
+        whitespace inside tags is handled, in theory, the ``preserve`` value
+        could be used to keep all whitespace as-is.  However, many current SVG
+        viewers don't obey that rule, so this option is provided as a workaround
+        and defaults to ``True``.
+    """
+    name = 'SVG'
+    aliases = ['svg']
+    filenames = ['*.svg']
+
+    def __init__(self, **options):
+        # XXX outencoding
+        Formatter.__init__(self, **options)
+        self.nowrap = get_bool_opt(options, 'nowrap', False)
+        self.fontfamily = options.get('fontfamily', 'monospace')
+        self.fontsize = options.get('fontsize', '14px')
+        self.xoffset = get_int_opt(options, 'xoffset', 0)
+        fs = self.fontsize.strip()
+        if fs.endswith('px'): fs = fs[:-2].strip()
+        try:
+            int_fs = int(fs)
+        except:
+            int_fs = 20
+        self.yoffset = get_int_opt(options, 'yoffset', int_fs)
+        self.ystep = get_int_opt(options, 'ystep', int_fs + 5)
+        self.spacehack = get_bool_opt(options, 'spacehack', True)
+        self._stylecache = {}
+
+    def format_unencoded(self, tokensource, outfile):
+        """
+        Format ``tokensource``, an iterable of ``(tokentype, tokenstring)``
+        tuples and write it into ``outfile``.
+
+        For our implementation we put all lines in their own 'line group'.
+        """
+        x = self.xoffset
+        y = self.yoffset
+        if not self.nowrap:
+            if self.encoding:
+                outfile.write('<?xml version="1.0" encoding="%s"?>\n' %
+                              self.encoding)
+            else:
+                outfile.write('<?xml version="1.0"?>\n')
+            outfile.write('<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" '
+                          '"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/'
+                          'svg10.dtd">\n')
+            outfile.write('<svg xmlns="http://www.w3.org/2000/svg">\n')
+            outfile.write('<g font-family="%s" font-size="%s">\n' %
+                          (self.fontfamily, self.fontsize))
+        outfile.write('<text x="%s" y="%s" xml:space="preserve">' % (x, y))
+        for ttype, value in tokensource:
+            style = self._get_style(ttype)
+            tspan = style and '<tspan' + style + '>' or ''
+            tspanend = tspan and '</tspan>' or ''
+            value = escape_html(value)
+            if self.spacehack:
+                value = value.expandtabs().replace(' ', '&#160;')
+            parts = value.split('\n')
+            for part in parts[:-1]:
+                outfile.write(tspan + part + tspanend)
+                y += self.ystep
+                outfile.write('</text>\n<text x="%s" y="%s" '
+                              'xml:space="preserve">' % (x, y))
+            outfile.write(tspan + parts[-1] + tspanend)
+        outfile.write('</text>')
+
+        if not self.nowrap:
+            outfile.write('</g></svg>\n')
+
+    def _get_style(self, tokentype):
+        if tokentype in self._stylecache:
+            return self._stylecache[tokentype]
+        otokentype = tokentype
+        while not self.style.styles_token(tokentype):
+            tokentype = tokentype.parent
+        value = self.style.style_for_token(tokentype)
+        result = ''
+        if value['color']:
+            result = ' fill="#' + value['color'] + '"'
+        if value['bold']:
+            result += ' font-weight="bold"'
+        if value['italic']:
+            result += ' font-style="italic"'
+        self._stylecache[otokentype] = result
+        return result

data/vendor/pygments-main/pygments/formatters/terminal.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.formatters.terminal
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Formatter for terminal output with ANSI sequences.
+
+    :copyright: Copyright 2006-2012 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import sys
+
+from pygments.formatter import Formatter
+from pygments.token import Keyword, Name, Comment, String, Error, \
+     Number, Operator, Generic, Token, Whitespace
+from pygments.console import ansiformat
+from pygments.util import get_choice_opt
+
+
+__all__ = ['TerminalFormatter']
+
+
+#: Map token types to a tuple of color values for light and dark
+#: backgrounds.
+TERMINAL_COLORS = {
+    Token:              ('',            ''),
+
+    Whitespace:         ('lightgray',   'darkgray'),
+    Comment:            ('lightgray',   'darkgray'),
+    Comment.Preproc:    ('teal',        'turquoise'),
+    Keyword:            ('darkblue',    'blue'),
+    Keyword.Type:       ('teal',        'turquoise'),
+    Operator.Word:      ('purple',      'fuchsia'),
+    Name.Builtin:       ('teal',        'turquoise'),
+    Name.Function:      ('darkgreen',   'green'),
+    Name.Namespace:     ('_teal_',      '_turquoise_'),
+    Name.Class:         ('_darkgreen_', '_green_'),
+    Name.Exception:     ('teal',        'turquoise'),
+    Name.Decorator:     ('darkgray',    'lightgray'),
+    Name.Variable:      ('darkred',     'red'),
+    Name.Constant:      ('darkred',     'red'),
+    Name.Attribute:     ('teal',        'turquoise'),
+    Name.Tag:           ('blue',        'blue'),
+    String:             ('brown',       'brown'),
+    Number:             ('darkblue',    'blue'),
+
+    Generic.Deleted:    ('red',        'red'),
+    Generic.Inserted:   ('darkgreen',  'green'),
+    Generic.Heading:    ('**',         '**'),
+    Generic.Subheading: ('*purple*',   '*fuchsia*'),
+    Generic.Error:      ('red',        'red'),
+
+    Error:              ('_red_',      '_red_'),
+}
+
+
+class TerminalFormatter(Formatter):
+    r"""
+    Format tokens with ANSI color sequences, for output in a text console.
+    Color sequences are terminated at newlines, so that paging the output
+    works correctly.
+
+    The `get_style_defs()` method doesn't do anything special since there is
+    no support for common styles.
+
+    Options accepted:
+
+    `bg`
+        Set to ``"light"`` or ``"dark"`` depending on the terminal's background
+        (default: ``"light"``).
+
+    `colorscheme`
+        A dictionary mapping token types to (lightbg, darkbg) color names or
+        ``None`` (default: ``None`` = use builtin colorscheme).
+    """
+    name = 'Terminal'
+    aliases = ['terminal', 'console']
+    filenames = []
+
+    def __init__(self, **options):
+        Formatter.__init__(self, **options)
+        self.darkbg = get_choice_opt(options, 'bg',
+                                     ['light', 'dark'], 'light') == 'dark'
+        self.colorscheme = options.get('colorscheme', None) or TERMINAL_COLORS
+
+    def format(self, tokensource, outfile):
+        # hack: if the output is a terminal and has an encoding set,
+        # use that to avoid unicode encode problems
+        if not self.encoding and hasattr(outfile, "encoding") and \
+           hasattr(outfile, "isatty") and outfile.isatty() and \
+           sys.version_info < (3,):
+            self.encoding = outfile.encoding
+        return Formatter.format(self, tokensource, outfile)
+
+    def format_unencoded(self, tokensource, outfile):
+        for ttype, value in tokensource:
+            color = self.colorscheme.get(ttype)
+            while color is None:
+                ttype = ttype[:-1]
+                color = self.colorscheme.get(ttype)
+            if color:
+                color = color[self.darkbg]
+                spl = value.split('\n')
+                for line in spl[:-1]:
+                    if line:
+                        outfile.write(ansiformat(color, line))
+                    outfile.write('\n')
+                if spl[-1]:
+                    outfile.write(ansiformat(color, spl[-1]))
+            else:
+                outfile.write(value)

data/vendor/pygments-main/pygments/formatters/terminal256.py

@@ -0,0 +1,222 @@
+# -*- coding: utf-8 -*-
+"""
+    pygments.formatters.terminal256
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Formatter for 256-color terminal output with ANSI sequences.
+
+    RGB-to-XTERM color conversion routines adapted from xterm256-conv
+    tool (http://frexx.de/xterm-256-notes/data/xterm256-conv2.tar.bz2)
+    by Wolfgang Frisch.
+
+    Formatter version 1.
+
+    :copyright: Copyright 2006-2012 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+# TODO:
+#  - Options to map style's bold/underline/italic/border attributes
+#    to some ANSI attrbutes (something like 'italic=underline')
+#  - An option to output "style RGB to xterm RGB/index" conversion table
+#  - An option to indicate that we are running in "reverse background"
+#    xterm. This means that default colors are white-on-black, not
+#    black-on-while, so colors like "white background" need to be converted
+#    to "white background, black foreground", etc...
+
+import sys
+
+from pygments.formatter import Formatter
+
+
+__all__ = ['Terminal256Formatter']
+
+
+class EscapeSequence:
+    def __init__(self, fg=None, bg=None, bold=False, underline=False):
+        self.fg = fg
+        self.bg = bg
+        self.bold = bold
+        self.underline = underline
+
+    def escape(self, attrs):
+        if len(attrs):
+            return "\x1b[" + ";".join(attrs) + "m"
+        return ""
+
+    def color_string(self):
+        attrs = []
+        if self.fg is not None:
+            attrs.extend(("38", "5", "%i" % self.fg))
+        if self.bg is not None:
+            attrs.extend(("48", "5", "%i" % self.bg))
+        if self.bold:
+            attrs.append("01")
+        if self.underline:
+            attrs.append("04")
+        return self.escape(attrs)
+
+    def reset_string(self):
+        attrs = []
+        if self.fg is not None:
+            attrs.append("39")
+        if self.bg is not None:
+            attrs.append("49")
+        if self.bold or self.underline:
+            attrs.append("00")
+        return self.escape(attrs)
+
+class Terminal256Formatter(Formatter):
+    r"""
+    Format tokens with ANSI color sequences, for output in a 256-color
+    terminal or console. Like in `TerminalFormatter` color sequences
+    are terminated at newlines, so that paging the output works correctly.
+
+    The formatter takes colors from a style defined by the `style` option
+    and converts them to nearest ANSI 256-color escape sequences. Bold and
+    underline attributes from the style are preserved (and displayed).
+
+    *New in Pygments 0.9.*
+
+    Options accepted:
+
+    `style`
+        The style to use, can be a string or a Style subclass (default:
+        ``'default'``).
+    """
+    name = 'Terminal256'
+    aliases = ['terminal256', 'console256', '256']
+    filenames = []
+
+    def __init__(self, **options):
+        Formatter.__init__(self, **options)
+
+        self.xterm_colors = []
+        self.best_match = {}
+        self.style_string = {}
+
+        self.usebold = 'nobold' not in options
+        self.useunderline = 'nounderline' not in options
+
+        self._build_color_table() # build an RGB-to-256 color conversion table
+        self._setup_styles() # convert selected style's colors to term. colors
+
+    def _build_color_table(self):
+        # colors 0..15: 16 basic colors
+
+        self.xterm_colors.append((0x00, 0x00, 0x00)) # 0
+        self.xterm_colors.append((0xcd, 0x00, 0x00)) # 1
+        self.xterm_colors.append((0x00, 0xcd, 0x00)) # 2
+        self.xterm_colors.append((0xcd, 0xcd, 0x00)) # 3
+        self.xterm_colors.append((0x00, 0x00, 0xee)) # 4
+        self.xterm_colors.append((0xcd, 0x00, 0xcd)) # 5
+        self.xterm_colors.append((0x00, 0xcd, 0xcd)) # 6
+        self.xterm_colors.append((0xe5, 0xe5, 0xe5)) # 7
+        self.xterm_colors.append((0x7f, 0x7f, 0x7f)) # 8
+        self.xterm_colors.append((0xff, 0x00, 0x00)) # 9
+        self.xterm_colors.append((0x00, 0xff, 0x00)) # 10
+        self.xterm_colors.append((0xff, 0xff, 0x00)) # 11
+        self.xterm_colors.append((0x5c, 0x5c, 0xff)) # 12
+        self.xterm_colors.append((0xff, 0x00, 0xff)) # 13
+        self.xterm_colors.append((0x00, 0xff, 0xff)) # 14
+        self.xterm_colors.append((0xff, 0xff, 0xff)) # 15
+
+        # colors 16..232: the 6x6x6 color cube
+
+        valuerange = (0x00, 0x5f, 0x87, 0xaf, 0xd7, 0xff)
+
+        for i in range(217):
+            r = valuerange[(i // 36) % 6]
+            g = valuerange[(i // 6) % 6]
+            b = valuerange[i % 6]
+            self.xterm_colors.append((r, g, b))
+
+        # colors 233..253: grayscale
+
+        for i in range(1, 22):
+            v = 8 + i * 10
+            self.xterm_colors.append((v, v, v))
+
+    def _closest_color(self, r, g, b):
+        distance = 257*257*3 # "infinity" (>distance from #000000 to #ffffff)
+        match = 0
+
+        for i in range(0, 254):
+            values = self.xterm_colors[i]
+
+            rd = r - values[0]
+            gd = g - values[1]
+            bd = b - values[2]
+            d = rd*rd + gd*gd + bd*bd
+
+            if d < distance:
+                match = i
+                distance = d
+        return match
+
+    def _color_index(self, color):
+        index = self.best_match.get(color, None)
+        if index is None:
+            try:
+                rgb = int(str(color), 16)
+            except ValueError:
+                rgb = 0
+
+            r = (rgb >> 16) & 0xff
+            g = (rgb >> 8) & 0xff
+            b = rgb & 0xff
+            index = self._closest_color(r, g, b)
+            self.best_match[color] = index
+        return index
+
+    def _setup_styles(self):
+        for ttype, ndef in self.style:
+            escape = EscapeSequence()
+            if ndef['color']:
+                escape.fg = self._color_index(ndef['color'])
+            if ndef['bgcolor']:
+                escape.bg = self._color_index(ndef['bgcolor'])
+            if self.usebold and ndef['bold']:
+                escape.bold = True
+            if self.useunderline and ndef['underline']:
+                escape.underline = True
+            self.style_string[str(ttype)] = (escape.color_string(),
+                                             escape.reset_string())
+
+    def format(self, tokensource, outfile):
+        # hack: if the output is a terminal and has an encoding set,
+        # use that to avoid unicode encode problems
+        if not self.encoding and hasattr(outfile, "encoding") and \
+           hasattr(outfile, "isatty") and outfile.isatty() and \
+           sys.version_info < (3,):
+            self.encoding = outfile.encoding
+        return Formatter.format(self, tokensource, outfile)
+
+    def format_unencoded(self, tokensource, outfile):
+        for ttype, value in tokensource:
+            not_found = True
+            while ttype and not_found:
+                try:
+                    #outfile.write( "<" + str(ttype) + ">" )
+                    on, off = self.style_string[str(ttype)]
+
+                    # Like TerminalFormatter, add "reset colors" escape sequence
+                    # on newline.
+                    spl = value.split('\n')
+                    for line in spl[:-1]:
+                        if line:
+                            outfile.write(on + line + off)
+                        outfile.write('\n')
+                    if spl[-1]:
+                        outfile.write(on + spl[-1] + off)
+
+                    not_found = False
+                    #outfile.write( '#' + str(ttype) + '#' )
+
+                except KeyError:
+                    #ottype = ttype
+                    ttype = ttype[:-1]
+                    #outfile.write( '!' + str(ottype) + '->' + str(ttype) + '!' )
+
+            if not_found:
+                outfile.write(value)