pygments.rb 0.6.3 → 1.0.0

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

@@ -1,180 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Pygments HTML formatter tests
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from __future__ import print_function
-
-import io
-import os
-import re
-import unittest
-import tempfile
-from os.path import join, dirname, isfile
-
-from pygments.util import StringIO
-from pygments.lexers import PythonLexer
-from pygments.formatters import HtmlFormatter, NullFormatter
-from pygments.formatters.html import escape_html
-
-import support
-
-TESTFILE, TESTDIR = support.location(__file__)
-
-fp = io.open(TESTFILE, encoding='utf-8')
-try:
-    tokensource = list(PythonLexer().get_tokens(fp.read()))
-finally:
-    fp.close()
-
-
-class HtmlFormatterTest(unittest.TestCase):
-    def test_correct_output(self):
-        hfmt = HtmlFormatter(nowrap=True)
-        houtfile = StringIO()
-        hfmt.format(tokensource, houtfile)
-
-        nfmt = NullFormatter()
-        noutfile = StringIO()
-        nfmt.format(tokensource, noutfile)
-
-        stripped_html = re.sub('<.*?>', '', houtfile.getvalue())
-        escaped_text = escape_html(noutfile.getvalue())
-        self.assertEqual(stripped_html, escaped_text)
-
-    def test_external_css(self):
-        # test correct behavior
-        # CSS should be in /tmp directory
-        fmt1 = HtmlFormatter(full=True, cssfile='fmt1.css', outencoding='utf-8')
-        # CSS should be in TESTDIR (TESTDIR is absolute)
-        fmt2 = HtmlFormatter(full=True, cssfile=join(TESTDIR, 'fmt2.css'),
-                             outencoding='utf-8')
-        tfile = tempfile.NamedTemporaryFile(suffix='.html')
-        fmt1.format(tokensource, tfile)
-        try:
-            fmt2.format(tokensource, tfile)
-            self.assertTrue(isfile(join(TESTDIR, 'fmt2.css')))
-        except IOError:
-            # test directory not writable
-            pass
-        tfile.close()
-
-        self.assertTrue(isfile(join(dirname(tfile.name), 'fmt1.css')))
-        os.unlink(join(dirname(tfile.name), 'fmt1.css'))
-        try:
-            os.unlink(join(TESTDIR, 'fmt2.css'))
-        except OSError:
-            pass
-
-    def test_all_options(self):
-        for optdict in [dict(nowrap=True),
-                        dict(linenos=True),
-                        dict(linenos=True, full=True),
-                        dict(linenos=True, full=True, noclasses=True)]:
-
-            outfile = StringIO()
-            fmt = HtmlFormatter(**optdict)
-            fmt.format(tokensource, outfile)
-
-    def test_linenos(self):
-        optdict = dict(linenos=True)
-        outfile = StringIO()
-        fmt = HtmlFormatter(**optdict)
-        fmt.format(tokensource, outfile)
-        html = outfile.getvalue()
-        self.assertTrue(re.search("<pre>\s+1\s+2\s+3", html))
-
-    def test_linenos_with_startnum(self):
-        optdict = dict(linenos=True, linenostart=5)
-        outfile = StringIO()
-        fmt = HtmlFormatter(**optdict)
-        fmt.format(tokensource, outfile)
-        html = outfile.getvalue()
-        self.assertTrue(re.search("<pre>\s+5\s+6\s+7", html))
-
-    def test_lineanchors(self):
-        optdict = dict(lineanchors="foo")
-        outfile = StringIO()
-        fmt = HtmlFormatter(**optdict)
-        fmt.format(tokensource, outfile)
-        html = outfile.getvalue()
-        self.assertTrue(re.search("<pre><a name=\"foo-1\">", html))
-
-    def test_lineanchors_with_startnum(self):
-        optdict = dict(lineanchors="foo", linenostart=5)
-        outfile = StringIO()
-        fmt = HtmlFormatter(**optdict)
-        fmt.format(tokensource, outfile)
-        html = outfile.getvalue()
-        self.assertTrue(re.search("<pre><a name=\"foo-5\">", html))
-
-    def test_valid_output(self):
-        # test all available wrappers
-        fmt = HtmlFormatter(full=True, linenos=True, noclasses=True,
-                            outencoding='utf-8')
-
-        handle, pathname = tempfile.mkstemp('.html')
-        tfile = os.fdopen(handle, 'w+b')
-        fmt.format(tokensource, tfile)
-        tfile.close()
-        catname = os.path.join(TESTDIR, 'dtds', 'HTML4.soc')
-        try:
-            import subprocess
-            po = subprocess.Popen(['nsgmls', '-s', '-c', catname, pathname],
-                                  stdout=subprocess.PIPE)
-            ret = po.wait()
-            output = po.stdout.read()
-            po.stdout.close()
-        except OSError:
-            # nsgmls not available
-            pass
-        else:
-            if ret:
-                print(output)
-            self.assertFalse(ret, 'nsgmls run reported errors')
-
-        os.unlink(pathname)
-
-    def test_get_style_defs(self):
-        fmt = HtmlFormatter()
-        sd = fmt.get_style_defs()
-        self.assertTrue(sd.startswith('.'))
-
-        fmt = HtmlFormatter(cssclass='foo')
-        sd = fmt.get_style_defs()
-        self.assertTrue(sd.startswith('.foo'))
-        sd = fmt.get_style_defs('.bar')
-        self.assertTrue(sd.startswith('.bar'))
-        sd = fmt.get_style_defs(['.bar', '.baz'])
-        fl = sd.splitlines()[0]
-        self.assertTrue('.bar' in fl and '.baz' in fl)
-
-    def test_unicode_options(self):
-        fmt = HtmlFormatter(title=u'Föö',
-                            cssclass=u'bär',
-                            cssstyles=u'div:before { content: \'bäz\' }',
-                            encoding='utf-8')
-        handle, pathname = tempfile.mkstemp('.html')
-        tfile = os.fdopen(handle, 'w+b')
-        fmt.format(tokensource, tfile)
-        tfile.close()
-
-    def test_ctags(self):
-        try:
-            import ctags
-        except ImportError:
-            # we can't check without the ctags module, but at least check the exception
-            self.assertRaises(RuntimeError, HtmlFormatter, tagsfile='support/tags')
-        else:
-            # this tagfile says that test_ctags() is on line 165, even if it isn't
-            # anymore in the actual source
-            fmt = HtmlFormatter(tagsfile='support/tags', lineanchors='L',
-                                tagurlformat='%(fname)s%(fext)s')
-            outfile = StringIO()
-            fmt.format(tokensource, outfile)
-            self.assertTrue('<a href="test_html_formatter.py#L-165">test_ctags</a>'
-                            in outfile.getvalue())

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

@@ -1,57 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Pygments LaTeX formatter tests
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-from __future__ import print_function
-
-import os
-import unittest
-import tempfile
-
-from pygments.formatters import LatexFormatter
-from pygments.lexers import PythonLexer
-
-import support
-
-TESTFILE, TESTDIR = support.location(__file__)
-
-
-class LatexFormatterTest(unittest.TestCase):
-
-    def test_valid_output(self):
-        fp = open(TESTFILE)
-        try:
-            tokensource = list(PythonLexer().get_tokens(fp.read()))
-        finally:
-            fp.close()
-        fmt = LatexFormatter(full=True, encoding='latin1')
-
-        handle, pathname = tempfile.mkstemp('.tex')
-        # place all output files in /tmp too
-        old_wd = os.getcwd()
-        os.chdir(os.path.dirname(pathname))
-        tfile = os.fdopen(handle, 'wb')
-        fmt.format(tokensource, tfile)
-        tfile.close()
-        try:
-            import subprocess
-            po = subprocess.Popen(['latex', '-interaction=nonstopmode',
-                                   pathname], stdout=subprocess.PIPE)
-            ret = po.wait()
-            output = po.stdout.read()
-            po.stdout.close()
-        except OSError:
-            # latex not available
-            pass
-        else:
-            if ret:
-                print(output)
-            self.assertFalse(ret, 'latex run reported errors')
-
-        os.unlink(pathname)
-        os.chdir(old_wd)

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

@@ -1,68 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Tests for other lexers
-    ~~~~~~~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import glob
-import os
-import unittest
-
-from pygments.lexers import guess_lexer
-from pygments.lexers.other import RexxLexer
-
-
-def _exampleFilePath(filename):
-    return os.path.join(os.path.dirname(__file__), 'examplefiles', filename)
-
-
-class AnalyseTextTest(unittest.TestCase):
-    def _testCanRecognizeAndGuessExampleFiles(self, lexer):
-        assert lexer is not None
-
-        for pattern in lexer.filenames:
-            exampleFilesPattern = _exampleFilePath(pattern)
-            for exampleFilePath in glob.glob(exampleFilesPattern):
-                exampleFile = open(exampleFilePath, 'rb')
-                try:
-                    text = exampleFile.read().decode('utf-8')
-                    probability = lexer.analyse_text(text)
-                    self.assertTrue(probability > 0,
-                        '%s must recognize %r' % (
-                        lexer.name, exampleFilePath))
-                    guessedLexer = guess_lexer(text)
-                    self.assertEqual(guessedLexer.name, lexer.name)
-                finally:
-                    exampleFile.close()
-
-    def testCanRecognizeAndGuessExampleFiles(self):
-        self._testCanRecognizeAndGuessExampleFiles(RexxLexer)
-
-
-class RexxLexerTest(unittest.TestCase):
-    def testCanGuessFromText(self):
-        self.assertAlmostEqual(0.01,
-            RexxLexer.analyse_text('/* */'))
-        self.assertAlmostEqual(1.0,
-            RexxLexer.analyse_text('''/* Rexx */
-                say "hello world"'''))
-        val = RexxLexer.analyse_text('/* */\n'
-                'hello:pRoceduRe\n'
-                '  say "hello world"')
-        self.assertTrue(val > 0.5, val)
-        val = RexxLexer.analyse_text('''/* */
-                if 1 > 0 then do
-                    say "ok"
-                end
-                else do
-                    say "huh?"
-                end''')
-        self.assertTrue(val > 0.2, val)
-        val = RexxLexer.analyse_text('''/* */
-                greeting = "hello world!"
-                parse value greeting "hello" name "!"
-                say name''')
-        self.assertTrue(val > 0.2, val)

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

@@ -1,81 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Basic CLexer Test
-    ~~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2006-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 ObjectiveCLexer
-
-
-class ObjectiveCLexerTest(unittest.TestCase):
-
-    def setUp(self):
-        self.lexer = ObjectiveCLexer()
-
-    def testLiteralNumberInt(self):
-        fragment = u'@(1);\n'
-        expected = [
-            (Token.Literal, u'@('),
-            (Token.Literal.Number.Integer, u'1'),
-            (Token.Literal, u')'),
-            (Token.Punctuation, u';'),
-            (Token.Text, u'\n'),
-        ]
-        self.assertEqual(expected, list(self.lexer.get_tokens(fragment)))
-
-    def testLiteralNumberExpression(self):
-        fragment = u'@(1+2);\n'
-        expected = [
-            (Token.Literal, u'@('),
-            (Token.Literal.Number.Integer, u'1'),
-            (Token.Operator, u'+'),
-            (Token.Literal.Number.Integer, u'2'),
-            (Token.Literal, u')'),
-            (Token.Punctuation, u';'),
-            (Token.Text, u'\n'),
-        ]
-        self.assertEqual(expected, list(self.lexer.get_tokens(fragment)))
-
-    def testLiteralNumberNestedExpression(self):
-        fragment = u'@(1+(2+3));\n'
-        expected = [
-            (Token.Literal, u'@('),
-            (Token.Literal.Number.Integer, u'1'),
-            (Token.Operator, u'+'),
-            (Token.Punctuation, u'('),
-            (Token.Literal.Number.Integer, u'2'),
-            (Token.Operator, u'+'),
-            (Token.Literal.Number.Integer, u'3'),
-            (Token.Punctuation, u')'),
-            (Token.Literal, u')'),
-            (Token.Punctuation, u';'),
-            (Token.Text, u'\n'),
-        ]
-        self.assertEqual(expected, list(self.lexer.get_tokens(fragment)))
-
-    def testLiteralNumberBool(self):
-        fragment = u'@NO;\n'
-        expected = [
-            (Token.Literal.Number, u'@NO'),
-            (Token.Punctuation, u';'),
-            (Token.Text, u'\n'),
-        ]
-        self.assertEqual(expected, list(self.lexer.get_tokens(fragment)))
-
-    def testLieralNumberBoolExpression(self):
-        fragment = u'@(YES);\n'
-        expected = [
-            (Token.Literal, u'@('),
-            (Token.Name.Builtin, u'YES'),
-            (Token.Literal, u')'),
-            (Token.Punctuation, u';'),
-            (Token.Text, u'\n'),
-        ]
-        self.assertEqual(expected, list(self.lexer.get_tokens(fragment)))

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

@@ -1,137 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    Pygments regex lexer tests
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import time
-import unittest
-
-from pygments.token import String
-from pygments.lexers.agile import PerlLexer
-
-
-class RunawayRegexTest(unittest.TestCase):
-    # A previous version of the Perl lexer would spend a great deal of
-    # time backtracking when given particular strings.  These tests show that
-    # the runaway backtracking doesn't happen any more (at least for the given
-    # cases).
-
-    lexer = PerlLexer()
-
-    ### Test helpers.
-
-    def assert_single_token(self, s, token):
-        """Show that a given string generates only one token."""
-        tokens = list(self.lexer.get_tokens_unprocessed(s))
-        self.assertEqual(len(tokens), 1, tokens)
-        self.assertEqual(s, tokens[0][2])
-        self.assertEqual(token, tokens[0][1])
-
-    def assert_tokens(self, strings, expected_tokens):
-        """Show that a given string generates the expected tokens."""
-        tokens = list(self.lexer.get_tokens_unprocessed(''.join(strings)))
-        self.assertEqual(len(tokens), len(expected_tokens), tokens)
-        for index, s in enumerate(strings):
-            self.assertEqual(s, tokens[index][2])
-            self.assertEqual(expected_tokens[index], tokens[index][1])
-
-    def assert_fast_tokenization(self, s):
-        """Show that a given string is tokenized quickly."""
-        start = time.time()
-        tokens = list(self.lexer.get_tokens_unprocessed(s))
-        end = time.time()
-        # Isn't 10 seconds kind of a long time?  Yes, but we don't want false
-        # positives when the tests are starved for CPU time.
-        if end-start > 10:
-            self.fail('tokenization took too long')
-        return tokens
-
-    ### Strings.
-
-    def test_single_quote_strings(self):
-        self.assert_single_token(r"'foo\tbar\\\'baz'", String)
-        self.assert_fast_tokenization("'" + '\\'*999)
-
-    def test_double_quote_strings(self):
-        self.assert_single_token(r'"foo\tbar\\\"baz"', String)
-        self.assert_fast_tokenization('"' + '\\'*999)
-
-    def test_backtick_strings(self):
-        self.assert_single_token(r'`foo\tbar\\\`baz`', String.Backtick)
-        self.assert_fast_tokenization('`' + '\\'*999)
-
-    ### Regex matches with various delimiters.
-
-    def test_match(self):
-        self.assert_single_token(r'/aa\tbb/', String.Regex)
-        self.assert_fast_tokenization('/' + '\\'*999)
-
-    def test_match_with_slash(self):
-        self.assert_tokens(['m', '/\n\\t\\\\/'], [String.Regex, String.Regex])
-        self.assert_fast_tokenization('m/xxx\n' + '\\'*999)
-
-    def test_match_with_bang(self):
-        self.assert_tokens(['m', r'!aa\t\!bb!'], [String.Regex, String.Regex])
-        self.assert_fast_tokenization('m!' + '\\'*999)
-
-    def test_match_with_brace(self):
-        self.assert_tokens(['m', r'{aa\t\}bb}'], [String.Regex, String.Regex])
-        self.assert_fast_tokenization('m{' + '\\'*999)
-
-    def test_match_with_angle_brackets(self):
-        self.assert_tokens(['m', r'<aa\t\>bb>'], [String.Regex, String.Regex])
-        self.assert_fast_tokenization('m<' + '\\'*999)
-
-    def test_match_with_parenthesis(self):
-        self.assert_tokens(['m', r'(aa\t\)bb)'], [String.Regex, String.Regex])
-        self.assert_fast_tokenization('m(' + '\\'*999)
-
-    def test_match_with_at_sign(self):
-        self.assert_tokens(['m', r'@aa\t\@bb@'], [String.Regex, String.Regex])
-        self.assert_fast_tokenization('m@' + '\\'*999)
-
-    def test_match_with_percent_sign(self):
-        self.assert_tokens(['m', r'%aa\t\%bb%'], [String.Regex, String.Regex])
-        self.assert_fast_tokenization('m%' + '\\'*999)
-
-    def test_match_with_dollar_sign(self):
-        self.assert_tokens(['m', r'$aa\t\$bb$'], [String.Regex, String.Regex])
-        self.assert_fast_tokenization('m$' + '\\'*999)
-
-    ### Regex substitutions with various delimeters.
-
-    def test_substitution_with_slash(self):
-        self.assert_single_token('s/aaa/bbb/g', String.Regex)
-        self.assert_fast_tokenization('s/foo/' + '\\'*999)
-
-    def test_substitution_with_at_sign(self):
-        self.assert_single_token(r's@aaa@bbb@g', String.Regex)
-        self.assert_fast_tokenization('s@foo@' + '\\'*999)
-
-    def test_substitution_with_percent_sign(self):
-        self.assert_single_token(r's%aaa%bbb%g', String.Regex)
-        self.assert_fast_tokenization('s%foo%' + '\\'*999)
-
-    def test_substitution_with_brace(self):
-        self.assert_single_token(r's{aaa}', String.Regex)
-        self.assert_fast_tokenization('s{' + '\\'*999)
-
-    def test_substitution_with_angle_bracket(self):
-        self.assert_single_token(r's<aaa>', String.Regex)
-        self.assert_fast_tokenization('s<' + '\\'*999)
-
-    def test_substitution_with_angle_bracket(self):
-        self.assert_single_token(r's<aaa>', String.Regex)
-        self.assert_fast_tokenization('s<' + '\\'*999)
-
-    def test_substitution_with_square_bracket(self):
-        self.assert_single_token(r's[aaa]', String.Regex)
-        self.assert_fast_tokenization('s[' + '\\'*999)
-
-    def test_substitution_with_parenthesis(self):
-        self.assert_single_token(r's(aaa)', String.Regex)
-        self.assert_fast_tokenization('s(' + '\\'*999)