pygments.rb 1.2.1 → 2.2.0

data/vendor/pygments-main/doc/pygmentize.1

@@ -1,94 +0,0 @@
-.TH PYGMENTIZE 1 "February 15, 2007"
-
-.SH NAME
-pygmentize \- highlights the input file
-
-.SH SYNOPSIS
-.B \fBpygmentize\fP
-.RI  [-l\ \fI<lexer>\fP]\ [-F\ \fI<filter>\fP[:\fI<options>\fP]]\ [-f\ \fI<formatter>\fP]
-.RI  [-O\ \fI<options>\fP]\ [-P\ \fI<option=value>\fP]\ [-o\ \fI<outfile>\fP]\ [\fI<infile>\fP]
-.br
-.B \fBpygmentize\fP
-.RI -S\ \fI<style>\fP\ -f\ \fI<formatter>\fP\ [-a\ \fI<arg>\fP]\ [-O\ \fI<options>\fP]\ [-P\ \fI<option=value>\fP]
-.br
-.B \fBpygmentize\fP
-.RI -L\ [\fI<which>\fP\ ...]
-.br
-.B \fBpygmentize\fP
-.RI -H\ \fI<type>\fP\ \fI<name>\fP
-.br
-.B \fBpygmentize\fP
-.RI -h\ |\ -V
-
-.SH DESCRIPTION
-Pygments is a generic syntax highlighter for general use in all kinds
-of software such as forum systems, wikis or other applications that need to
-prettify source code.
-.PP
-Its highlights are:
-  * a wide range of common languages and markup formats is supported
-  * special attention is paid to details, increasing quality by a fair amount
-  * support for new languages and formats are added easily
-  * a number of output formats, presently HTML, LaTeX and ANSI sequences
-  * it is usable as a command-line tool and as a library
-  * ... and it highlights even Brainfuck!
-.PP
-\fBpygmentize\fP is a command that uses Pygments to highlight the input file and
-write the result to \fI<outfile>\fP. If no \fI<infile>\fP is given, stdin is used.
-.SH OPTIONS
-A summary of options is included below.
-.TP
-.B \-l \fI<lexer>\fP
-Set the lexer name. If not given, the lexer is guessed from the extension of the
-input file name (this obviously doesn't work if the input is stdin).
-.TP
-.B \-F \fI<filter>\fP[:\fI<options>\fP]
-Add a filter to the token stream. You can give options in the same way as for
--O after a colon (note: there must not be spaces around the colon).
-This option can be given multiple times.
-.TP
-.B \-f \fI<formatter>\fP
-Set the formatter name. If not given, it will be guessed from the extension of
-the output file name. If no output file is given, the terminal formatter will be
-used by default.
-.TP
-.B \-o \fI<outfile>\fP
-Set output file. If not given, stdout is used.
-.TP
-.B \-O \fI<options>\fP
-With this option, you can give the lexer and formatter a comma-separated list of
-options, e.g. "-O bg=light,python=cool". Which options are valid for which
-lexers and formatters can be found in the documentation.
-This option can be given multiple times.
-.TP
-.B \-P \fI<option=value>\fP
-This option adds lexer and formatter options like the -O option, but
-you can only give one option per -P. That way, the option value may contain
-commas and equals signs, which it can't with -O.
-.TP
-.B \-S \fI<style>\fP
-Print out style definitions for style \fI<style>\fP and for formatter \fI<formatter>\fP.
-The meaning of the argument given by
-.B \-a \fI<arg>\fP
-is formatter dependent and can be found in the documentation.
-.TP
-.B \-L [\fI<which>\fP ...]
-List lexers, formatters, styles or filters. Set \fI<which>\fP to the thing you want
-to list (e.g. "styles"), or omit it to list everything.
-.TP
-.B \-H \fI<type>\fP \fI<name>\fP
-Print detailed help for the object \fI<name>\fP of type \fI<type>\fP, where \fI<type>\fP is one
-of "lexer", "formatter" or "filter".
-.TP
-.B \-h
-Show help screen.
-.TP
-.B \-V
-Show version of the Pygments package.
-.SH SEE ALSO
-/usr/share/doc/python-pygments/index.html
-.SH AUTHOR
-pygmentize was written by Georg Brandl <g.brandl@gmx.net>.
-.PP
-This manual page was written by Piotr Ozarowski <ozarow@gmail.com>,
-for the Debian project (but may be used by others).

data/vendor/pygments-main/external/autopygmentize

@@ -1,101 +0,0 @@
-#!/bin/bash
-# Best effort auto-pygmentization with transparent decompression
-# by Reuben Thomas 2008-2016
-# This program is in the public domain.
-
-# Strategy: first see if pygmentize can find a lexer; if not, ask file; if that finds nothing, fail
-# Set the environment variable PYGMENTIZE_OPTS or pass options before the file path to configure pygments.
-
-# This program can be used as a .lessfilter for the less pager to auto-color less's output
-
-file="${!#}"              # last argument
-options=${@:1:$(($#-1))}  # handle others args as options to pass to pygmentize
-
-file_common_opts="--brief --dereference"
-
-lexer=$(pygmentize -N "$file")
-if [[ "$lexer" == text ]]; then
-    unset lexer
-    case $(file --mime-type --uncompress $file_common_opts "$file") in
-        application/xml|image/svg+xml) lexer=xml;;
-        application/javascript) lexer=javascript;;
-        text/html) lexer=html;;
-        text/troff) lexer=nroff;;
-        text/x-asm) lexer=nasm;;
-        text/x-awk) lexer=awk;;
-        text/x-c) lexer=c;;
-        text/x-c++) lexer=cpp;;
-        text/x-crystal) lexer=crystal;;
-        text/x-diff) lexer=diff;;
-        text/x-fortran) lexer=fortran;;
-        text/x-gawk) lexer=gawk;;
-        text/x-java) lexer=java;;
-        text/x-lisp) lexer=common-lisp;;
-        text/x-lua) lexer=lua;;
-        text/x-makefile) lexer=make;;
-        text/x-msdos-batch) lexer=bat;;
-        text/x-nawk) lexer=nawk;;
-        text/x-pascal) lexer=pascal;;
-        text/x-perl) lexer=perl;;
-        text/x-php) lexer=php;;
-        text/x-po) lexer=po;;
-        text/x-python) lexer=python;;
-        text/x-ruby) lexer=ruby;;
-        text/x-shellscript) lexer=sh;;
-        text/x-tcl) lexer=tcl;;
-        text/x-tex|text/x-texinfo) lexer=latex;; # FIXME: texinfo really needs its own lexer
-        
-        # Types that file outputs which pygmentize didn't support as of file 5.20, pygments 2.0
-        # text/calendar
-        # text/inf
-        # text/PGP
-        # text/rtf
-        # text/texmacs
-        # text/vnd.graphviz
-        # text/x-bcpl
-        # text/x-info
-        # text/x-m4
-        # text/x-vcard
-        # text/x-xmcd
-        
-        text/plain)  # special filenames. TODO: insert more
-            case $(basename "$file") in
-                .zshrc) lexer=sh;;
-            esac
-            ;;
-    esac
-fi
-
-# Find a preprocessor for compressed files
-concat=cat
-case $(file $file_common_opts --mime-type "$file") in
-    application/x-gzip)  concat=zcat;;
-    application/x-bzip2) concat=bzcat;;
-    application/x-xz)    concat=xzcat;;
-esac
-
-# Find a suitable lexer, preceded by a hex dump for binary files
-prereader=""
-encoding=$(file --mime-encoding --uncompress $file_common_opts "$file")
-if [[ $encoding == "binary" ]]; then
-    prereader="od -x" # POSIX fallback
-    if [[ -n $(which hd) ]]; then
-        prereader="hd" # preferred
-    fi
-    lexer=hexdump
-    encoding=latin1
-fi
-if [[ -n "$lexer" ]]; then
-    reader="pygmentize -O inencoding=$encoding $PYGMENTIZE_OPTS $options -l $lexer"
-fi
-
-# If we found a reader, run it
-if [[ -n "$reader" ]]; then
-    if [[ -n "$prereader" ]]; then
-        exec $concat "$file" | $prereader | $reader
-    else
-        exec $concat "$file" | $reader
-    fi
-fi
-
-exit 1

data/vendor/pygments-main/external/lasso-builtins-generator-9.lasso

@@ -1,162 +0,0 @@
-#!/usr/bin/lasso9
-
-/*
-	Builtins Generator for Lasso 9
-
-	This is the shell script that was used to extract Lasso 9's built-in keywords
-	and generate most of the _lasso_builtins.py file. When run, it creates a file
-	containing the types, traits, methods, and members of the currently-installed
-	version of Lasso 9.
-
-	A list of tags in Lasso 8 can be generated with this code:
-
-	<?LassoScript
-		local('l8tags' = list,
-					'l8libs' = array('Cache','ChartFX','Client','Database','File','HTTP',
-						'iCal','Lasso','Link','List','PDF','Response','Stock','String',
-						'Thread','Valid','WAP','XML'));
-		iterate(#l8libs, local('library'));
-			local('result' = namespace_load(#library));
-		/iterate;
-		iterate(tags_list, local('i'));
-			#l8tags->insert(string_removeleading(#i, -pattern='_global_'));
-		/iterate;
-		#l8tags->sort;
-		iterate(#l8tags, local('i'));
-			string_lowercase(#i)+"<br>";
-		/iterate;
-
-*/
-
-output("This output statement is required for a complete list of methods.")
-local(f) = file("_lasso_builtins-9.py")
-#f->doWithClose => {
-
-#f->openTruncate
-#f->writeString('# -*- coding: utf-8 -*-
-"""
-    pygments.lexers._lasso_builtins
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    Built-in Lasso types, traits, methods, and members.
-
-    :copyright: Copyright 2006-'+date->year+' by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-')
-
-// Load and register contents of $LASSO9_MASTER_HOME/LassoModules/
-database_initialize
-
-// Load all of the libraries from builtins and lassoserver
-// This forces all possible available types and methods to be registered
-local(srcs =
-	(:
-		dir(sys_masterHomePath + '/LassoLibraries/builtins/')->eachFilePath,
-		dir(sys_masterHomePath + '/LassoLibraries/lassoserver/')->eachFilePath
-	)
-)
-
-with topLevelDir in delve(#srcs)
-where not #topLevelDir->lastComponent->beginsWith('.')
-do protect => {
-	handle_error => {
-		stdoutnl('Unable to load: ' + #topLevelDir + ' ' + error_msg)
-	}
-	library_thread_loader->loadLibrary(#topLevelDir)
-	stdoutnl('Loaded: ' + #topLevelDir)
-}
-
-email_initialize
-log_initialize
-session_initialize
-
-local(
-	typesList = set(),
-	traitsList = set(),
-	unboundMethodsList = set(),
-	memberMethodsList = set()
-)
-
-// types
-with type in sys_listTypes
-where not #type->asString->endsWith('$')		// skip threads
-do {
-	#typesList->insert(#type)
-}
-
-// traits
-with trait in sys_listTraits
-where not #trait->asString->beginsWith('$')		// skip combined traits
-do {
-	#traitsList->insert(#trait)
-}
-
-// member methods
-with type in #typesList
-do {
-	with method in #type->getType->listMethods
-	where #method->typeName == #type	 // skip inherited methods
-	let name = #method->methodName
-	where not #name->asString->endsWith('=')		// skip setter methods
-	where #name->asString->isAlpha(1)		// skip unpublished methods
-	do {
-		#memberMethodsList->insert(#name)
-	}
-}
-with trait in #traitsList
-do {
-	with method in #trait->getType->provides
-	where #method->typeName == #trait		// skip inherited methods
-	let name = #method->methodName
-	where not #name->asString->endsWith('=')		// skip setter methods
-	where #name->asString->isAlpha(1)		// skip unpublished methods
-	do {
-		#memberMethodsList->insert(#name)
-	}
-}
-
-// unbound methods
-with method in sys_listUnboundMethods
-let name = #method->methodName
-where not #name->asString->endsWith('=')		// skip setter methods
-where #name->asString->isAlpha(1)		// skip unpublished methods
-where #typesList !>> #name
-where #traitsList !>> #name
-do {
-	#unboundMethodsList->insert(#name)
-}
-
-// write to file
-with i in (:
-	pair(#typesList, "BUILTINS = {
-    'Types': (
-"),
-	pair(#traitsList, "    ),
-    'Traits': (
-"),
-	pair(#unboundMethodsList, "    ),
-    'Unbound Methods': (
-"),
-	pair(#memberMethodsList, "    )
-}
-MEMBERS = {
-    'Member Methods': (
-")
-)
-do {
-	#f->writeString(#i->second)
-	with t in (#i->first)
-	let ts = #t->asString
-	order by #ts
-	do {
-		#f->writeString("        '"+#ts->lowercase&asString+"',\n")
-	}
-}
-
-#f->writeString("    )
-}
-")
-
-}

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))