pygments.rb 0.6.3 → 1.0.0

data/vendor/pygments-main/tests/run.py

@@ -1,44 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Pygments unit tests
-    ~~~~~~~~~~~~~~~~~~
-
-    Usage::
-
-        python run.py [testfile ...]
-
-
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from __future__ import print_function
-
-import sys, os
-
-# only find tests in this directory
-if os.path.dirname(__file__):
-    os.chdir(os.path.dirname(__file__))
-
-
-try:
-    import nose
-except ImportError:
-    print('nose is required to run the Pygments test suite')
-    sys.exit(1)
-
-try:
-    # make sure the current source is first on sys.path
-    sys.path.insert(0, '..')
-    import pygments
-except SyntaxError as err:
-    print('Syntax error: %s' % err)
-    sys.exit(1)
-except ImportError as err:
-    print('Cannot find Pygments to test: %s' % err)
-    sys.exit(1)
-else:
-    print('Pygments %s test suite running (Python %s)...' %
-          (pygments.__version__, sys.version.split()[0]))
-
-nose.main()

data/vendor/pygments-main/tests/string_asserts.py

@@ -1,22 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Pygments string assert utility
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-class StringTests(object):
-
-    def assertStartsWith(self, haystack, needle, msg=None):
-        if msg is None:
-            msg = "'{}' does not start with '{}'".format(haystack, needle)
-        if not haystack.startswith(needle):
-            raise(AssertionError(msg))
-
-    def assertEndsWith(self, haystack, needle, msg=None):
-        if msg is None:
-            msg = "'{}' does not end with '{}'".format(haystack, needle)
-        if not haystack.endswith(needle):
-            raise(AssertionError(msg))

data/vendor/pygments-main/tests/support.py

@@ -1,15 +0,0 @@
-# coding: utf-8
-"""
-Support for Pygments tests
-"""
-
-import os
-
-
-def location(mod_name):
-    """
-    Return the file and directory that the code for *mod_name* is in.
-    """
-    source = mod_name.endswith("pyc") and mod_name[:-1] or mod_name
-    source = os.path.abspath(source)
-    return source, os.path.dirname(source)

data/vendor/pygments-main/tests/support/tags

@@ -1,36 +0,0 @@
-!_TAG_FILE_FORMAT	2	/extended format; --format=1 will not append ;" to lines/
-!_TAG_FILE_SORTED	1	/0=unsorted, 1=sorted, 2=foldcase/
-!_TAG_PROGRAM_AUTHOR	Darren Hiebert	/dhiebert@users.sourceforge.net/
-!_TAG_PROGRAM_NAME	Exuberant Ctags	//
-!_TAG_PROGRAM_URL	http://ctags.sourceforge.net	/official site/
-!_TAG_PROGRAM_VERSION	5.8	//
-HtmlFormatter	test_html_formatter.py	19;"	i
-HtmlFormatterTest	test_html_formatter.py	34;"	c
-NullFormatter	test_html_formatter.py	19;"	i
-PythonLexer	test_html_formatter.py	18;"	i
-StringIO	test_html_formatter.py	13;"	i
-dirname	test_html_formatter.py	16;"	i
-escape_html	test_html_formatter.py	20;"	i
-fp	test_html_formatter.py	27;"	v
-inspect	test_html_formatter.py	15;"	i
-isfile	test_html_formatter.py	16;"	i
-join	test_html_formatter.py	16;"	i
-os	test_html_formatter.py	10;"	i
-re	test_html_formatter.py	11;"	i
-subprocess	test_html_formatter.py	125;"	i
-support	test_html_formatter.py	23;"	i
-tempfile	test_html_formatter.py	14;"	i
-test_all_options	test_html_formatter.py	72;"	m	class:HtmlFormatterTest
-test_correct_output	test_html_formatter.py	35;"	m	class:HtmlFormatterTest
-test_ctags	test_html_formatter.py	165;"	m	class:HtmlFormatterTest
-test_external_css	test_html_formatter.py	48;"	m	class:HtmlFormatterTest
-test_get_style_defs	test_html_formatter.py	141;"	m	class:HtmlFormatterTest
-test_lineanchors	test_html_formatter.py	98;"	m	class:HtmlFormatterTest
-test_lineanchors_with_startnum	test_html_formatter.py	106;"	m	class:HtmlFormatterTest
-test_linenos	test_html_formatter.py	82;"	m	class:HtmlFormatterTest
-test_linenos_with_startnum	test_html_formatter.py	90;"	m	class:HtmlFormatterTest
-test_unicode_options	test_html_formatter.py	155;"	m	class:HtmlFormatterTest
-test_valid_output	test_html_formatter.py	114;"	m	class:HtmlFormatterTest
-tokensource	test_html_formatter.py	29;"	v
-uni_open	test_html_formatter.py	21;"	i
-unittest	test_html_formatter.py	12;"	i

data/vendor/pygments-main/tests/test_basic_api.py

@@ -1,309 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Pygments basic API tests
-    ~~~~~~~~~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from __future__ import print_function
-
-import random
-import unittest
-
-from pygments import lexers, formatters, filters, format
-from pygments.token import _TokenType, Text
-from pygments.lexer import RegexLexer
-from pygments.formatters.img import FontNotFound
-from pygments.util import text_type, StringIO, xrange, ClassNotFound
-
-import support
-
-TESTFILE, TESTDIR = support.location(__file__)
-
-test_content = [chr(i) for i in xrange(33, 128)] * 5
-random.shuffle(test_content)
-test_content = ''.join(test_content) + '\n'
-
-
-def test_lexer_import_all():
-    # instantiate every lexer, to see if the token type defs are correct
-    for x in lexers.LEXERS:
-        c = getattr(lexers, x)()
-
-
-def test_lexer_classes():
-    # test that every lexer class has the correct public API
-    def verify(cls):
-        assert type(cls.name) is str
-        for attr in 'aliases', 'filenames', 'alias_filenames', 'mimetypes':
-            assert hasattr(cls, attr)
-            assert type(getattr(cls, attr)) is list, \
-                   "%s: %s attribute wrong" % (cls, attr)
-        result = cls.analyse_text("abc")
-        assert isinstance(result, float) and 0.0 <= result <= 1.0
-        result = cls.analyse_text(".abc")
-        assert isinstance(result, float) and 0.0 <= result <= 1.0
-
-        assert all(al.lower() == al for al in cls.aliases)
-
-        inst = cls(opt1="val1", opt2="val2")
-        if issubclass(cls, RegexLexer):
-            if not hasattr(cls, '_tokens'):
-                # if there's no "_tokens", the lexer has to be one with
-                # multiple tokendef variants
-                assert cls.token_variants
-                for variant in cls.tokens:
-                    assert 'root' in cls.tokens[variant]
-            else:
-                assert 'root' in cls._tokens, \
-                       '%s has no root state' % cls
-
-        if cls.name in ['XQuery', 'Opa']:   # XXX temporary
-            return
-
-        try:
-            tokens = list(inst.get_tokens(test_content))
-        except KeyboardInterrupt:
-            raise KeyboardInterrupt('interrupted %s.get_tokens(): test_content=%r' % (cls.__name__, test_content))
-        txt = ""
-        for token in tokens:
-            assert isinstance(token, tuple)
-            assert isinstance(token[0], _TokenType)
-            if isinstance(token[1], str):
-                print(repr(token[1]))
-            assert isinstance(token[1], text_type)
-            txt += token[1]
-        assert txt == test_content, "%s lexer roundtrip failed: %r != %r" % \
-               (cls.name, test_content, txt)
-
-    for lexer in lexers._iter_lexerclasses():
-        yield verify, lexer
-
-
-def test_lexer_options():
-    # test that the basic options work
-    def ensure(tokens, output):
-        concatenated = ''.join(token[1] for token in tokens)
-        assert concatenated == output, \
-               '%s: %r != %r' % (lexer, concatenated, output)
-    def verify(cls):
-        inst = cls(stripnl=False)
-        ensure(inst.get_tokens('a\nb'), 'a\nb\n')
-        ensure(inst.get_tokens('\n\n\n'), '\n\n\n')
-        inst = cls(stripall=True)
-        ensure(inst.get_tokens('   \n  b\n\n\n'), 'b\n')
-        # some lexers require full lines in input
-        if cls.__name__ not in (
-            'PythonConsoleLexer', 'RConsoleLexer', 'RubyConsoleLexer',
-            'SqliteConsoleLexer', 'MatlabSessionLexer', 'ErlangShellLexer',
-            'BashSessionLexer', 'LiterateHaskellLexer', 'LiterateAgdaLexer',
-            'PostgresConsoleLexer', 'ElixirConsoleLexer', 'JuliaConsoleLexer',
-            'RobotFrameworkLexer', 'DylanConsoleLexer', 'ShellSessionLexer',
-            'LiterateIdrisLexer', 'LiterateCryptolLexer'):
-            inst = cls(ensurenl=False)
-            ensure(inst.get_tokens('a\nb'), 'a\nb')
-            inst = cls(ensurenl=False, stripall=True)
-            ensure(inst.get_tokens('a\nb\n\n'), 'a\nb')
-
-    for lexer in lexers._iter_lexerclasses():
-        if lexer.__name__ == 'RawTokenLexer':
-            # this one is special
-            continue
-        yield verify, lexer
-
-
-def test_get_lexers():
-    # test that the lexers functions work
-    def verify(func, args):
-        x = func(opt='val', *args)
-        assert isinstance(x, lexers.PythonLexer)
-        assert x.options["opt"] == "val"
-
-    for func, args in [(lexers.get_lexer_by_name, ("python",)),
-                       (lexers.get_lexer_for_filename, ("test.py",)),
-                       (lexers.get_lexer_for_mimetype, ("text/x-python",)),
-                       (lexers.guess_lexer, ("#!/usr/bin/python -O\nprint",)),
-                       (lexers.guess_lexer_for_filename, ("a.py", "<%= @foo %>"))
-                       ]:
-        yield verify, func, args
-
-    for cls, (_, lname, aliases, _, mimetypes) in lexers.LEXERS.items():
-        assert cls == lexers.find_lexer_class(lname).__name__
-
-        for alias in aliases:
-            assert cls == lexers.get_lexer_by_name(alias).__class__.__name__
-
-        for mimetype in mimetypes:
-            assert cls == lexers.get_lexer_for_mimetype(mimetype).__class__.__name__
-
-    try:
-        lexers.get_lexer_by_name(None)
-    except ClassNotFound:
-        pass
-    else:
-        raise Exception
-
-
-def test_formatter_public_api():
-    ts = list(lexers.PythonLexer().get_tokens("def f(): pass"))
-    out = StringIO()
-    # test that every formatter class has the correct public API
-    def verify(formatter, info):
-        assert len(info) == 4
-        assert info[0], "missing formatter name"
-        assert info[1], "missing formatter aliases"
-        assert info[3], "missing formatter docstring"
-
-        if formatter.name == 'Raw tokens':
-            # will not work with Unicode output file
-            return
-
-        try:
-            inst = formatter(opt1="val1")
-        except (ImportError, FontNotFound):
-            return
-        try:
-            inst.get_style_defs()
-        except NotImplementedError:
-            # may be raised by formatters for which it doesn't make sense
-            pass
-        inst.format(ts, out)
-
-    for formatter, info in formatters.FORMATTERS.items():
-        yield verify, formatter, info
-
-def test_formatter_encodings():
-    from pygments.formatters import HtmlFormatter
-
-    # unicode output
-    fmt = HtmlFormatter()
-    tokens = [(Text, u"ä")]
-    out = format(tokens, fmt)
-    assert type(out) is text_type
-    assert u"ä" in out
-
-    # encoding option
-    fmt = HtmlFormatter(encoding="latin1")
-    tokens = [(Text, u"ä")]
-    assert u"ä".encode("latin1") in format(tokens, fmt)
-
-    # encoding and outencoding option
-    fmt = HtmlFormatter(encoding="latin1", outencoding="utf8")
-    tokens = [(Text, u"ä")]
-    assert u"ä".encode("utf8") in format(tokens, fmt)
-
-
-def test_formatter_unicode_handling():
-    # test that the formatter supports encoding and Unicode
-    tokens = list(lexers.PythonLexer(encoding='utf-8').
-                  get_tokens("def f(): 'ä'"))
-
-    def verify(formatter):
-        try:
-            inst = formatter(encoding=None)
-        except (ImportError, FontNotFound):
-            # some dependency or font not installed
-            return
-
-        if formatter.name != 'Raw tokens':
-            out = format(tokens, inst)
-            if formatter.unicodeoutput:
-                assert type(out) is text_type
-
-            inst = formatter(encoding='utf-8')
-            out = format(tokens, inst)
-            assert type(out) is bytes, '%s: %r' % (formatter, out)
-            # Cannot test for encoding, since formatters may have to escape
-            # non-ASCII characters.
-        else:
-            inst = formatter()
-            out = format(tokens, inst)
-            assert type(out) is bytes, '%s: %r' % (formatter, out)
-
-    for formatter, info in formatters.FORMATTERS.items():
-        yield verify, formatter
-
-
-def test_get_formatters():
-    # test that the formatters functions work
-    x = formatters.get_formatter_by_name("html", opt="val")
-    assert isinstance(x, formatters.HtmlFormatter)
-    assert x.options["opt"] == "val"
-
-    x = formatters.get_formatter_for_filename("a.html", opt="val")
-    assert isinstance(x, formatters.HtmlFormatter)
-    assert x.options["opt"] == "val"
-
-
-def test_styles():
-    # minimal style test
-    from pygments.formatters import HtmlFormatter
-    fmt = HtmlFormatter(style="pastie")
-
-
-class FiltersTest(unittest.TestCase):
-
-    def test_basic(self):
-        filter_args = {
-            'whitespace': {'spaces': True, 'tabs': True, 'newlines': True},
-            'highlight': {'names': ['isinstance', 'lexers', 'x']},
-        }
-        for x in filters.FILTERS:
-            lx = lexers.PythonLexer()
-            lx.add_filter(x, **filter_args.get(x, {}))
-            fp = open(TESTFILE, 'rb')
-            try:
-                text = fp.read().decode('utf-8')
-            finally:
-                fp.close()
-            tokens = list(lx.get_tokens(text))
-            roundtext = ''.join([t[1] for t in tokens])
-            if x not in ('whitespace', 'keywordcase'):
-                # these filters change the text
-                self.assertEqual(roundtext, text,
-                                 "lexer roundtrip with %s filter failed" % x)
-
-    def test_raiseonerror(self):
-        lx = lexers.PythonLexer()
-        lx.add_filter('raiseonerror', excclass=RuntimeError)
-        self.assertRaises(RuntimeError, list, lx.get_tokens('$'))
-
-    def test_whitespace(self):
-        lx = lexers.PythonLexer()
-        lx.add_filter('whitespace', spaces='%')
-        fp = open(TESTFILE, 'rb')
-        try:
-            text = fp.read().decode('utf-8')
-        finally:
-            fp.close()
-        lxtext = ''.join([t[1] for t in list(lx.get_tokens(text))])
-        self.assertFalse(' ' in lxtext)
-
-    def test_keywordcase(self):
-        lx = lexers.PythonLexer()
-        lx.add_filter('keywordcase', case='capitalize')
-        fp = open(TESTFILE, 'rb')
-        try:
-            text = fp.read().decode('utf-8')
-        finally:
-            fp.close()
-        lxtext = ''.join([t[1] for t in list(lx.get_tokens(text))])
-        self.assertTrue('Def' in lxtext and 'Class' in lxtext)
-
-    def test_codetag(self):
-        lx = lexers.PythonLexer()
-        lx.add_filter('codetagify')
-        text = u'# BUG: text'
-        tokens = list(lx.get_tokens(text))
-        self.assertEqual('# ', tokens[0][1])
-        self.assertEqual('BUG', tokens[1][1])
-
-    def test_codetag_boundary(self):
-        # ticket #368
-        lx = lexers.PythonLexer()
-        lx.add_filter('codetagify')
-        text = u'# DEBUG: text'
-        tokens = list(lx.get_tokens(text))
-        self.assertEqual('# DEBUG: text', tokens[0][1])

data/vendor/pygments-main/tests/test_cfm.py

@@ -1,46 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Basic ColdfusionHtmlLexer Test
-    ~~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import unittest
-import os
-
-from pygments.token import Token
-from pygments.lexers import ColdfusionHtmlLexer
-
-
-class ColdfusionHtmlLexerTest(unittest.TestCase):
-
-    def setUp(self):
-        self.lexer = ColdfusionHtmlLexer()
-
-    def testBasicComment(self):
-        fragment = u'<!--- cfcomment --->'
-        expected = [
-            (Token.Text, u''),
-            (Token.Comment.Multiline, u'<!---'),
-            (Token.Comment.Multiline, u' cfcomment '),
-            (Token.Comment.Multiline, u'--->'),
-            (Token.Text, u'\n'),
-        ]
-        self.assertEqual(expected, list(self.lexer.get_tokens(fragment)))
-
-    def testNestedComment(self):
-        fragment = u'<!--- nested <!--- cfcomment ---> --->'
-        expected = [
-            (Token.Text, u''),
-            (Token.Comment.Multiline, u'<!---'),
-            (Token.Comment.Multiline, u' nested '),
-            (Token.Comment.Multiline, u'<!---'),
-            (Token.Comment.Multiline, u' cfcomment '),
-            (Token.Comment.Multiline, u'--->'),
-            (Token.Comment.Multiline, u' '),
-            (Token.Comment.Multiline, u'--->'),
-            (Token.Text, u'\n'),
-        ]
-        self.assertEqual(expected, list(self.lexer.get_tokens(fragment)))