pygments.rb 1.2.1 → 2.2.0

data/vendor/pygments-main/doc/docs/lexers.rst

@@ -1,69 +0,0 @@
-.. -*- mode: rst -*-
-
-================
-Available lexers
-================
-
-This page lists all available builtin lexers and the options they take.
-
-Currently, **all lexers** support these options:
-
-`stripnl`
-    Strip leading and trailing newlines from the input (default: ``True``)
-
-`stripall`
-    Strip all leading and trailing whitespace from the input (default:
-    ``False``).
-
-`ensurenl`
-    Make sure that the input ends with a newline (default: ``True``).  This
-    is required for some lexers that consume input linewise.
-
-    .. versionadded:: 1.3
-
-`tabsize`
-    If given and greater than 0, expand tabs in the input (default: ``0``).
-
-`encoding`
-    If given, must be an encoding name (such as ``"utf-8"``). This encoding
-    will be used to convert the input string to Unicode (if it is not already
-    a Unicode string). The default is ``"guess"``.
-
-    If this option is set to ``"guess"``, a simple UTF-8 vs. Latin-1
-    detection is used, if it is set to ``"chardet"``, the
-    `chardet library <https://chardet.github.io/>`_ is used to
-    guess the encoding of the input.
-
-    .. versionadded:: 0.6
-
-
-The "Short Names" field lists the identifiers that can be used with the
-`get_lexer_by_name()` function.
-
-These lexers are builtin and can be imported from `pygments.lexers`:
-
-.. pygmentsdoc:: lexers
-
-
-Iterating over all lexers
--------------------------
-
-.. versionadded:: 0.6
-
-To get all lexers (both the builtin and the plugin ones), you can
-use the `get_all_lexers()` function from the `pygments.lexers`
-module:
-
-.. sourcecode:: pycon
-
-    >>> from pygments.lexers import get_all_lexers
-    >>> i = get_all_lexers()
-    >>> i.next()
-    ('Diff', ('diff',), ('*.diff', '*.patch'), ('text/x-diff', 'text/x-patch'))
-    >>> i.next()
-    ('Delphi', ('delphi', 'objectpascal', 'pas', 'pascal'), ('*.pas',), ('text/x-pascal',))
-    >>> i.next()
-    ('XML+Ruby', ('xml+erb', 'xml+ruby'), (), ())
-
-As you can see, the return value is an iterator which yields tuples
-in the form ``(name, aliases, filetypes, mimetypes)``.

data/vendor/pygments-main/doc/docs/moinmoin.rst

@@ -1,39 +0,0 @@
-.. -*- mode: rst -*-
-
-============================
-Using Pygments with MoinMoin
-============================
-
-From Pygments 0.7, the source distribution ships a `Moin`_ parser plugin that
-can be used to get Pygments highlighting in Moin wiki pages.
-
-To use it, copy the file `external/moin-parser.py` from the Pygments
-distribution to the `data/plugin/parser` subdirectory of your Moin instance.
-Edit the options at the top of the file (currently ``ATTACHMENTS`` and
-``INLINESTYLES``) and rename the file to 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
-    [...]
-    }}}
-
-where ``python`` is the Pygments name of the lexer to use.
-
-Additionally, if you set the ``ATTACHMENTS`` option 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 to True.
-
-
-.. _Moin: http://moinmoin.wikiwikiweb.de/

data/vendor/pygments-main/doc/docs/plugins.rst

@@ -1,93 +0,0 @@
-================
-Register Plugins
-================
-
-If you want to extend Pygments without hacking the sources, but want to
-use the lexer/formatter/style/filter lookup functions (`lexers.get_lexer_by_name`
-et al.), you can use `setuptools`_ entrypoints to add new lexers, formatters
-or styles as if they were in the Pygments core.
-
-.. _setuptools: http://peak.telecommunity.com/DevCenter/setuptools
-
-That means you can use your highlighter modules with the `pygmentize` script,
-which relies on the mentioned functions.
-
-
-Entrypoints
-===========
-
-Here is a list of setuptools entrypoints that Pygments understands:
-
-`pygments.lexers`
-
-    This entrypoint is used for adding new lexers to the Pygments core.
-    The name of the entrypoint values doesn't really matter, Pygments extracts
-    required metadata from the class definition:
-
-    .. sourcecode:: ini
-
-        [pygments.lexers]
-        yourlexer = yourmodule:YourLexer
-
-    Note that you have to define ``name``, ``aliases`` and ``filename``
-    attributes so that you can use the highlighter from the command line:
-
-    .. sourcecode:: python
-
-        class YourLexer(...):
-            name = 'Name Of Your Lexer'
-            aliases = ['alias']
-            filenames = ['*.ext']
-
-
-`pygments.formatters`
-
-    You can use this entrypoint to add new formatters to Pygments. The
-    name of an entrypoint item is the name of the formatter. If you
-    prefix the name with a slash it's used as a filename pattern:
-
-    .. sourcecode:: ini
-
-        [pygments.formatters]
-        yourformatter = yourmodule:YourFormatter
-        /.ext = yourmodule:YourFormatter
-
-
-`pygments.styles`
-
-    To add a new style you can use this entrypoint. The name of the entrypoint
-    is the name of the style:
-
-    .. sourcecode:: ini
-
-        [pygments.styles]
-        yourstyle = yourmodule:YourStyle
-
-
-`pygments.filters`
-
-    Use this entrypoint to register a new filter. The name of the
-    entrypoint is the name of the filter:
-
-    .. sourcecode:: ini
-
-        [pygments.filters]
-        yourfilter = yourmodule:YourFilter
-
-
-How To Use Entrypoints
-======================
-
-This documentation doesn't explain how to use those entrypoints because this is
-covered in the `setuptools documentation`_. That page should cover everything
-you need to write a plugin.
-
-.. _setuptools documentation: http://peak.telecommunity.com/DevCenter/setuptools
-
-
-Extending The Core
-==================
-
-If you have written a Pygments plugin that is open source, please inform us
-about that. There is a high chance that we'll add it to the Pygments
-distribution.

data/vendor/pygments-main/doc/docs/quickstart.rst

@@ -1,205 +0,0 @@
-.. -*- mode: rst -*-
-
-===========================
-Introduction and Quickstart
-===========================
-
-
-Welcome to Pygments! This document explains the basic concepts and terms and
-gives a few examples of how to use the library.
-
-
-Architecture
-============
-
-There are four types of components that work together highlighting a piece of
-code:
-
-* A **lexer** splits the source into tokens, fragments of the source that
-  have a token type that determines what the text represents semantically
-  (e.g., keyword, string, or comment). There is a lexer for every language
-  or markup format that Pygments supports.
-* The token stream can be piped through **filters**, which usually modify
-  the token types or text fragments, e.g. uppercasing all keywords.
-* A **formatter** then takes the token stream and writes it to an output
-  file, in a format such as HTML, LaTeX or RTF.
-* While writing the output, a **style** determines how to highlight all the
-  different token types. It maps them to attributes like "red and bold".
-
-
-Example
-=======
-
-Here is a small example for highlighting Python code:
-
-.. sourcecode:: python
-
-    from pygments import highlight
-    from pygments.lexers import PythonLexer
-    from pygments.formatters import HtmlFormatter
-
-    code = 'print "Hello World"'
-    print highlight(code, PythonLexer(), HtmlFormatter())
-
-which prints something like this:
-
-.. sourcecode:: html
-
-    <div class="highlight">
-    <pre><span class="k">print</span> <span class="s">&quot;Hello World&quot;</span></pre>
-    </div>
-
-As you can see, Pygments uses CSS classes (by default, but you can change that)
-instead of inline styles in order to avoid outputting redundant style information over
-and over. A CSS stylesheet that contains all CSS classes possibly used in the output
-can be produced by:
-
-.. sourcecode:: python
-
-    print HtmlFormatter().get_style_defs('.highlight')
-
-The argument to :func:`get_style_defs` is used as an additional CSS selector:
-the output may look like this:
-
-.. sourcecode:: css
-
-    .highlight .k { color: #AA22FF; font-weight: bold }
-    .highlight .s { color: #BB4444 }
-    ...
-
-
-Options
-=======
-
-The :func:`highlight()` function supports a fourth argument called *outfile*, it
-must be a file object if given. The formatted output will then be written to
-this file instead of being returned as a string.
-
-Lexers and formatters both support options. They are given to them as keyword
-arguments either to the class or to the lookup method:
-
-.. sourcecode:: python
-
-    from pygments import highlight
-    from pygments.lexers import get_lexer_by_name
-    from pygments.formatters import HtmlFormatter
-
-    lexer = get_lexer_by_name("python", stripall=True)
-    formatter = HtmlFormatter(linenos=True, cssclass="source")
-    result = highlight(code, lexer, formatter)
-
-This makes the lexer strip all leading and trailing whitespace from the input
-(`stripall` option), lets the formatter output line numbers (`linenos` option),
-and sets the wrapping ``<div>``'s class to ``source`` (instead of
-``highlight``).
-
-Important options include:
-
-`encoding` : for lexers and formatters
-   Since Pygments uses Unicode strings internally, this determines which
-   encoding will be used to convert to or from byte strings.
-`style` : for formatters
-   The name of the style to use when writing the output.
-
-
-For an overview of builtin lexers and formatters and their options, visit the
-:doc:`lexer <lexers>` and :doc:`formatters <formatters>` lists.
-
-For a documentation on filters, see :doc:`this page <filters>`.
-
-
-Lexer and formatter lookup
-==========================
-
-If you want to lookup a built-in lexer by its alias or a filename, you can use
-one of the following methods:
-
-.. sourcecode:: pycon
-
-    >>> from pygments.lexers import (get_lexer_by_name,
-    ...     get_lexer_for_filename, get_lexer_for_mimetype)
-
-    >>> get_lexer_by_name('python')
-    <pygments.lexers.PythonLexer>
-
-    >>> get_lexer_for_filename('spam.rb')
-    <pygments.lexers.RubyLexer>
-
-    >>> get_lexer_for_mimetype('text/x-perl')
-    <pygments.lexers.PerlLexer>
-
-All these functions accept keyword arguments; they will be passed to the lexer
-as options.
-
-A similar API is available for formatters: use :func:`.get_formatter_by_name()`
-and :func:`.get_formatter_for_filename()` from the :mod:`pygments.formatters`
-module for this purpose.
-
-
-Guessing lexers
-===============
-
-If you don't know the content of the file, or you want to highlight a file
-whose extension is ambiguous, such as ``.html`` (which could contain plain HTML
-or some template tags), use these functions:
-
-.. sourcecode:: pycon
-
-    >>> from pygments.lexers import guess_lexer, guess_lexer_for_filename
-
-    >>> guess_lexer('#!/usr/bin/python\nprint "Hello World!"')
-    <pygments.lexers.PythonLexer>
-
-    >>> guess_lexer_for_filename('test.py', 'print "Hello World!"')
-    <pygments.lexers.PythonLexer>
-
-:func:`.guess_lexer()` passes the given content to the lexer classes'
-:meth:`analyse_text()` method and returns the one for which it returns the
-highest number.
-
-All lexers have two different filename pattern lists: the primary and the
-secondary one. The :func:`.get_lexer_for_filename()` function only uses the
-primary list, whose entries are supposed to be unique among all lexers.
-:func:`.guess_lexer_for_filename()`, however, will first loop through all lexers
-and look at the primary and secondary filename patterns if the filename matches.
-If only one lexer matches, it is returned, else the guessing mechanism of
-:func:`.guess_lexer()` is used with the matching lexers.
-
-As usual, keyword arguments to these functions are given to the created lexer
-as options.    
-
-
-Command line usage
-==================
-
-You can use Pygments from the command line, using the :program:`pygmentize`
-script::
-
-    $ pygmentize test.py
-
-will highlight the Python file test.py using ANSI escape sequences
-(a.k.a. terminal colors) and print the result to standard output.
-
-To output HTML, use the ``-f`` option::
-
-    $ pygmentize -f html -o test.html test.py
-
-to write an HTML-highlighted version of test.py to the file test.html.
-Note that it will only be a snippet of HTML, if you want a full HTML document,
-use the "full" option::
-
-    $ pygmentize -f html -O full -o test.html test.py
-
-This will produce a full HTML document with included stylesheet.
-
-A style can be selected with ``-O style=<name>``.
-
-If you need a stylesheet for an existing HTML file using Pygments CSS classes,
-it can be created with::
-
-    $ pygmentize -S default -f html > style.css
-
-where ``default`` is the style name.
-
-More options and tricks and be found in the :doc:`command line reference
-<cmdline>`.

data/vendor/pygments-main/doc/docs/rstdirective.rst

@@ -1,22 +0,0 @@
-.. -*- mode: rst -*-
-
-================================
-Using Pygments in ReST documents
-================================
-
-Many Python people use `ReST`_ for documentation their sourcecode, programs,
-scripts et cetera. This also means that documentation often includes sourcecode
-samples or snippets.
-
-You can easily enable Pygments support for your ReST texts using a custom
-directive -- this is also how this documentation displays source code.
-
-From Pygments 0.9, the directive is shipped in the distribution as
-`external/rst-directive.py`.  You can copy and adapt this code to your liking.
-
-.. removed -- too confusing
-   *Loosely related note:* The ReST lexer now recognizes ``.. sourcecode::`` and
-   ``.. code::`` directives and highlights the contents in the specified language
-   if the `handlecodeblocks` option is true.
-
-.. _ReST: http://docutils.sf.net/rst.html

data/vendor/pygments-main/doc/docs/styles.rst

@@ -1,201 +0,0 @@
-.. -*- mode: rst -*-
-
-======
-Styles
-======
-
-Pygments comes with some builtin styles that work for both the HTML and
-LaTeX formatter.
-
-The builtin styles can be looked up with the `get_style_by_name` function:
-
-.. sourcecode:: pycon
-
-    >>> from pygments.styles import get_style_by_name
-    >>> get_style_by_name('colorful')
-    <class 'pygments.styles.colorful.ColorfulStyle'>
-
-You can pass a instance of a `Style` class to a formatter as the `style`
-option in form of a string:
-
-.. sourcecode:: pycon
-
-    >>> from pygments.styles import get_style_by_name
-    >>> from pygments.formatters import HtmlFormatter
-    >>> HtmlFormatter(style='colorful').style
-    <class 'pygments.styles.colorful.ColorfulStyle'>
-
-Or you can also import your own style (which must be a subclass of
-`pygments.style.Style`) and pass it to the formatter:
-
-.. sourcecode:: pycon
-
-    >>> from yourapp.yourmodule import YourStyle
-    >>> from pygments.formatters import HtmlFormatter
-    >>> HtmlFormatter(style=YourStyle).style
-    <class 'yourapp.yourmodule.YourStyle'>
-
-
-Creating Own Styles
-===================
-
-So, how to create a style? All you have to do is to subclass `Style` and
-define some styles:
-
-.. sourcecode:: python
-
-    from pygments.style import Style
-    from pygments.token import Keyword, Name, Comment, String, Error, \
-         Number, Operator, Generic
-
-    class YourStyle(Style):
-        default_style = ""
-        styles = {
-            Comment:                'italic #888',
-            Keyword:                'bold #005',
-            Name:                   '#f00',
-            Name.Function:          '#0f0',
-            Name.Class:             'bold #0f0',
-            String:                 'bg:#eee #111'
-        }
-
-That's it. There are just a few rules. When you define a style for `Name`
-the style automatically also affects `Name.Function` and so on. If you
-defined ``'bold'`` and you don't want boldface for a subtoken use ``'nobold'``.
-
-(Philosophy: the styles aren't written in CSS syntax since this way
-they can be used for a variety of formatters.)
-
-`default_style` is the style inherited by all token types.
-
-To make the style usable for Pygments, you must
-
-* either register it as a plugin (see :doc:`the plugin docs <plugins>`)
-* or drop it into the `styles` subpackage of your Pygments distribution one style
-  class per style, where the file name is the style name and the class name is
-  `StylenameClass`. For example, if your style should be called
-  ``"mondrian"``, name the class `MondrianStyle`, put it into the file
-  ``mondrian.py`` and this file into the ``pygments.styles`` subpackage
-  directory.
-
-
-Style Rules
-===========
-
-Here a small overview of all allowed styles:
-
-``bold``
-    render text as bold
-``nobold``
-    don't render text as bold (to prevent subtokens being highlighted bold)
-``italic``
-    render text italic
-``noitalic``
-    don't render text as italic
-``underline``
-    render text underlined
-``nounderline``
-    don't render text underlined
-``bg:``
-    transparent background
-``bg:#000000``
-    background color (black)
-``border:``
-    no border
-``border:#ffffff``
-    border color (white)
-``#ff0000``
-    text color (red)
-``noinherit``
-    don't inherit styles from supertoken
-
-Note that there may not be a space between ``bg:`` and the color value
-since the style definition string is split at whitespace.
-Also, using named colors is not allowed since the supported color names
-vary for different formatters.
-
-Furthermore, not all lexers might support every style.
-
-
-Builtin Styles
-==============
-
-Pygments ships some builtin styles which are maintained by the Pygments team.
-
-To get a list of known styles you can use this snippet:
-
-.. sourcecode:: pycon
-
-    >>> from pygments.styles import STYLE_MAP
-    >>> STYLE_MAP.keys()
-    ['default', 'emacs', 'friendly', 'colorful']
-
-
-Getting a list of available styles
-==================================
-
-.. versionadded:: 0.6
-
-Because it could be that a plugin registered a style, there is
-a way to iterate over all styles:
-
-.. sourcecode:: pycon
-
-    >>> from pygments.styles import get_all_styles
-    >>> styles = list(get_all_styles())
-
-
-.. _AnsiTerminalStyle:
-
-Terminal Styles
-===============
-
-.. versionadded:: 2.2
-
-Custom styles used with the 256-color terminal formatter can also map colors to
-use the 8 default ANSI colors.  To do so, use ``#ansigreen``, ``#ansired`` or
-any other colors defined in :attr:`pygments.style.ansicolors`.  Foreground ANSI
-colors will be mapped to the corresponding `escape codes 30 to 37
-<https://en.wikipedia.org/wiki/ANSI_escape_code#Colors>`_ thus respecting any
-custom color mapping and themes provided by many terminal emulators.  Light
-variants are treated as foreground color with and an added bold flag.
-``bg:#ansi<color>`` will also be respected, except the light variant will be the
-same shade as their dark variant.
-
-See the following example where the color of the string ``"hello world"`` is
-governed by the escape sequence ``\x1b[34;01m`` (Ansi Blue, Bold, 41 being red
-background) instead of an extended foreground & background color.
-
-.. sourcecode:: pycon
-
-    >>> from pygments import highlight
-    >>> from pygments.style import Style
-    >>> from pygments.token import Token
-    >>> from pygments.lexers import Python3Lexer
-    >>> from pygments.formatters import Terminal256Formatter
-
-    >>> class MyStyle(Style):
-            styles = {
-                Token.String:     '#ansiblue bg:#ansired',
-            }
-
-    >>> code = 'print("Hello World")'
-    >>> result = highlight(code, Python3Lexer(), Terminal256Formatter(style=MyStyle))
-    >>> print(result.encode())
-    b'\x1b[34;41;01m"\x1b[39;49;00m\x1b[34;41;01mHello World\x1b[39;49;00m\x1b[34;41;01m"\x1b[39;49;00m'
-
-Colors specified using ``#ansi*`` are converted to a default set of RGB colors
-when used with formatters other than the terminal-256 formatter.
-
-By definition of ANSI, the following colors are considered "light" colors, and
-will be rendered by most terminals as bold:
-
-- "darkgray", "red", "green", "yellow", "blue", "fuchsia", "turquoise", "white"
-
-The following are considered "dark" colors and will be rendered as non-bold:
-
-- "black", "darkred", "darkgreen", "brown", "darkblue", "purple", "teal",
-  "lightgray"
-
-Exact behavior might depends on the terminal emulator you are using, and its
-settings.