pygments.rb 1.2.1 → 2.0.0

data/vendor/pygments-main/external/markdown-processor.py

@@ -1,67 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    The Pygments Markdown Preprocessor
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    This fragment is a Markdown_ preprocessor that renders source code
-    to HTML via Pygments.  To use it, invoke Markdown like so::
-
-        import markdown
-
-        html = markdown.markdown(someText, extensions=[CodeBlockExtension()])
-
-    This uses CSS classes by default, so use
-    ``pygmentize -S <some style> -f html > pygments.css``
-    to create a stylesheet to be added to the website.
-
-    You can then highlight source code in your markdown markup::
-
-        [sourcecode:lexer]
-        some code
-        [/sourcecode]
-
-    .. _Markdown: https://pypi.python.org/pypi/Markdown
-
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-# Options
-# ~~~~~~~
-
-# Set to True if you want inline CSS styles instead of classes
-INLINESTYLES = False
-
-
-import re
-
-from markdown.preprocessors import Preprocessor
-from markdown.extensions import Extension
-
-from pygments import highlight
-from pygments.formatters import HtmlFormatter
-from pygments.lexers import get_lexer_by_name, TextLexer
-
-
-class CodeBlockPreprocessor(Preprocessor):
-
-    pattern = re.compile(r'\[sourcecode:(.+?)\](.+?)\[/sourcecode\]', re.S)
-
-    formatter = HtmlFormatter(noclasses=INLINESTYLES)
-
-    def run(self, lines):
-        def repl(m):
-            try:
-                lexer = get_lexer_by_name(m.group(1))
-            except ValueError:
-                lexer = TextLexer()
-            code = highlight(m.group(2), lexer, self.formatter)
-            code = code.replace('\n\n', '\n&nbsp;\n').replace('\n', '<br />')
-            return '\n\n<div class="code">%s</div>\n\n' % code
-        joined_lines = "\n".join(lines)
-        joined_lines = self.pattern.sub(repl, joined_lines)
-        return joined_lines.split("\n")
-
-class CodeBlockExtension(Extension):
-    def extendMarkdown(self, md, md_globals):
-        md.preprocessors.add('CodeBlockPreprocessor', CodeBlockPreprocessor(), '_begin')

data/vendor/pygments-main/external/moin-parser.py

@@ -1,112 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    The Pygments MoinMoin Parser
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    This is a MoinMoin parser plugin that renders source code to HTML via
-    Pygments; you need Pygments 0.7 or newer for this parser to work.
-
-    To use it, set the options below to match your setup and put this file in
-    the data/plugin/parser subdirectory of your Moin instance, and give it the
-    name that the parser directive should have. For example, if you name the
-    file ``code.py``, you can get a highlighted Python code sample with this
-    Wiki markup::
-
-        {{{
-        #!code python
-        [...]
-        }}}
-
-    Additionally, if you set ATTACHMENTS below to True, Pygments will also be
-    called for all attachments for whose filenames there is no other parser
-    registered.
-
-    You are responsible for including CSS rules that will map the Pygments CSS
-    classes to colors. You can output a stylesheet file with `pygmentize`, put
-    it into the `htdocs` directory of your Moin instance and then include it in
-    the `stylesheets` configuration option in the Moin config, e.g.::
-
-        stylesheets = [('screen', '/htdocs/pygments.css')]
-
-    If you do not want to do that and are willing to accept larger HTML
-    output, you can set the INLINESTYLES option below to True.
-
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-# Options
-# ~~~~~~~
-
-# Set to True if you want to highlight attachments, in addition to
-# {{{ }}} blocks.
-ATTACHMENTS = True
-
-# Set to True if you want inline CSS styles instead of classes
-INLINESTYLES = False
-
-
-import sys
-
-from pygments import highlight
-from pygments.lexers import get_lexer_by_name, get_lexer_for_filename, TextLexer
-from pygments.formatters import HtmlFormatter
-from pygments.util import ClassNotFound
-
-
-# wrap lines in <span>s so that the Moin-generated line numbers work
-class MoinHtmlFormatter(HtmlFormatter):
-    def wrap(self, source, outfile):
-        for line in source:
-            yield 1, '<span class="line">' + line[1] + '</span>'
-
-htmlformatter = MoinHtmlFormatter(noclasses=INLINESTYLES)
-textlexer = TextLexer()
-codeid = [0]
-
-
-class Parser:
-    """
-    MoinMoin Pygments parser.
-    """
-    if ATTACHMENTS:
-        extensions = '*'
-    else:
-        extensions = []
-
-    Dependencies = []
-
-    def __init__(self, raw, request, **kw):
-        self.raw = raw
-        self.req = request
-        if "format_args" in kw:
-            # called from a {{{ }}} block
-            try:
-                self.lexer = get_lexer_by_name(kw['format_args'].strip())
-            except ClassNotFound:
-                self.lexer = textlexer
-            return
-        if "filename" in kw:
-            # called for an attachment
-            filename = kw['filename']
-        else:
-            # called for an attachment by an older moin
-            # HACK: find out the filename by peeking into the execution
-            #       frame which might not always work
-            try:
-                frame = sys._getframe(1)
-                filename = frame.f_locals['filename']
-            except:
-                filename = 'x.txt'
-        try:
-            self.lexer = get_lexer_for_filename(filename)
-        except ClassNotFound:
-            self.lexer = textlexer
-
-    def format(self, formatter):
-        codeid[0] += 1
-        id = "pygments_%s" % codeid[0]
-        w = self.req.write
-        w(formatter.code_area(1, id, start=1, step=1))
-        w(formatter.rawHTML(highlight(self.raw, self.lexer, htmlformatter)))
-        w(formatter.code_area(0, id))

data/vendor/pygments-main/external/pygments.bashcomp

@@ -1,38 +0,0 @@
-#!bash
-#
-# Bash completion support for Pygments (the 'pygmentize' command).
-#
-
-_pygmentize()
-{
-    local cur prev
-
-    COMPREPLY=()
-    cur=`_get_cword`
-    prev=${COMP_WORDS[COMP_CWORD-1]}
-
-    case "$prev" in
-        -f)
-            FORMATTERS=`pygmentize -L formatters | grep '* ' | cut -c3- | sed -e 's/,//g' -e 's/:$//'` 
-            COMPREPLY=( $( compgen -W '$FORMATTERS' -- "$cur" ) )
-            return 0
-            ;;
-        -l)
-            LEXERS=`pygmentize -L lexers | grep '* ' | cut -c3- | sed -e 's/,//g' -e 's/:$//'` 
-            COMPREPLY=( $( compgen -W '$LEXERS' -- "$cur" ) )
-            return 0
-            ;;
-        -S)
-            STYLES=`pygmentize -L styles | grep '* ' | cut -c3- | sed s/:$//`
-            COMPREPLY=( $( compgen -W '$STYLES' -- "$cur" ) )
-            return 0
-            ;;
-    esac
-
-    if [[ "$cur" == -* ]]; then
-        COMPREPLY=( $( compgen -W '-f -l -S -L -g -O -P -F \
-                                   -N -H -h -V -o' -- "$cur" ) )
-        return 0
-    fi
-}
-complete -F _pygmentize -o default pygmentize

data/vendor/pygments-main/external/rst-directive.py

@@ -1,82 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    The Pygments reStructuredText directive
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    This fragment is a Docutils_ 0.5 directive that renders source code
-    (to HTML only, currently) via Pygments.
-
-    To use it, adjust the options below and copy the code into a module
-    that you import on initialization.  The code then automatically
-    registers a ``sourcecode`` directive that you can use instead of
-    normal code blocks like this::
-
-        .. sourcecode:: python
-
-            My code goes here.
-
-    If you want to have different code styles, e.g. one with line numbers
-    and one without, add formatters with their names in the VARIANTS dict
-    below.  You can invoke them instead of the DEFAULT one by using a
-    directive option::
-
-        .. sourcecode:: python
-            :linenos:
-
-            My code goes here.
-
-    Look at the `directive documentation`_ to get all the gory details.
-
-    .. _Docutils: http://docutils.sf.net/
-    .. _directive documentation:
-       http://docutils.sourceforge.net/docs/howto/rst-directives.html
-
-    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-# Options
-# ~~~~~~~
-
-# Set to True if you want inline CSS styles instead of classes
-INLINESTYLES = False
-
-from pygments.formatters import HtmlFormatter
-
-# The default formatter
-DEFAULT = HtmlFormatter(noclasses=INLINESTYLES)
-
-# Add name -> formatter pairs for every variant you want to use
-VARIANTS = {
-    # 'linenos': HtmlFormatter(noclasses=INLINESTYLES, linenos=True),
-}
-
-
-from docutils import nodes
-from docutils.parsers.rst import directives, Directive
-
-from pygments import highlight
-from pygments.lexers import get_lexer_by_name, TextLexer
-
-class Pygments(Directive):
-    """ Source code syntax hightlighting.
-    """
-    required_arguments = 1
-    optional_arguments = 0
-    final_argument_whitespace = True
-    option_spec = dict([(key, directives.flag) for key in VARIANTS])
-    has_content = True
-
-    def run(self):
-        self.assert_has_content()
-        try:
-            lexer = get_lexer_by_name(self.arguments[0])
-        except ValueError:
-            # no lexer found - use the text one instead of an exception
-            lexer = TextLexer()
-        # take an arbitrary option if more than one is given
-        formatter = self.options and VARIANTS[list(self.options)[0]] or DEFAULT
-        parsed = highlight(u'\n'.join(self.content), lexer, formatter)
-        return [nodes.raw('', parsed, format='html')]
-
-directives.register_directive('sourcecode', Pygments)

data/vendor/pygments-main/pygmentize

@@ -1,8 +0,0 @@
-#!/usr/bin/env python2
-
-import sys
-import pygments.cmdline
-try:
-    sys.exit(pygments.cmdline.main(sys.argv))
-except KeyboardInterrupt:
-    sys.exit(1)