pygments.rb 0.5.4 → 0.6.0

data/vendor/pygments-main/tests/examplefiles/test.zep

@@ -0,0 +1,33 @@
+namespace Test;
+
+use Test\Foo;
+
+class Bar
+{
+    protected a;
+    private b;
+    public c {set, get};
+
+    public function __construct(string str, boolean bool)
+    {
+        let this->c = str;
+        this->setC(bool);
+        let this->b = [];
+    }
+
+    public function sayHello(string name)
+    {
+        echo "Hello " . name;
+    }
+
+    protected function loops()
+    {
+        for a in b {
+            echo a;
+        }
+        loop {
+            return "boo!";
+        }
+    }
+
+}

data/vendor/pygments-main/tests/examplefiles/unicode.go

@@ -0,0 +1,10 @@
+package main
+
+import "fmt"
+
+func main() {
+    世界 := "Hello, world!"
+    さようなら := "Goodbye, world!"
+    fmt.Println(世界)
+    fmt.Println(さようなら)
+}

data/vendor/pygments-main/tests/examplefiles/vctreestatus_hg

@@ -0,0 +1,4 @@
+M LICENSE
+M setup.py
+! setup.cfg
+? vctreestatus_hg

data/vendor/pygments-main/tests/examplefiles/vimrc

@@ -0,0 +1,21 @@
+" A comment
+
+:py print "py"
+::pyt print 'pyt'
+  pyth	print '''pyth'''
+ : pytho print "pytho"
+python print """python"""
+
+  : : python<<E OF
+print """my script"""
+
+def MyFunc(str):
+  """ My Function """
+  print str
+E OF
+
+let py = 42
+echo py
+
+let foo = 42
+echo foo

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

@@ -8,42 +8,37 @@
         python run.py [testfile ...]
 
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
+from __future__ import print_function
+
 import sys, os
 
-if sys.version_info >= (3,):
-    # copy test suite over to "build/lib" and convert it
-    print ('Copying and converting sources to build/lib/test...')
-    from distutils.util import copydir_run_2to3
-    testroot = os.path.dirname(__file__)
-    newroot = os.path.join(testroot, '..', 'build/lib/test')
-    copydir_run_2to3(testroot, newroot)
-    # make nose believe that we run from the converted dir
-    os.chdir(newroot)
-else:
-    # only find tests in this directory
-    if os.path.dirname(__file__):
-        os.chdir(os.path.dirname(__file__))
+# 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')
+    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 ImportError:
-    print ('Cannot find Pygments to test: %s' % sys.exc_info()[1])
+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]))
+    print('Pygments %s test suite running (Python %s)...' %
+          (pygments.__version__, sys.version.split()[0]))
 
 nose.main()

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

@@ -0,0 +1,22 @@
+# -*- 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/test_basic_api.py

@@ -3,11 +3,12 @@
     Pygments basic API tests
     ~~~~~~~~~~~~~~~~~~~~~~~~
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
-import os
+from __future__ import print_function
+
 import random
 import unittest
 
@@ -15,7 +16,7 @@ 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 BytesIO, StringIO, bytes, b
+from pygments.util import text_type, StringIO, xrange, ClassNotFound
 
 import support
 
@@ -28,7 +29,7 @@ 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.keys():
+    for x in lexers.LEXERS:
         c = getattr(lexers, x)()
 
 
@@ -45,6 +46,8 @@ def test_lexer_classes():
         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'):
@@ -60,14 +63,17 @@ def test_lexer_classes():
         if cls.name in ['XQuery', 'Opa']:   # XXX temporary
             return
 
-        tokens = list(inst.get_tokens(test_content))
+        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], unicode)
+                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)
@@ -94,7 +100,8 @@ def test_lexer_options():
             'SqliteConsoleLexer', 'MatlabSessionLexer', 'ErlangShellLexer',
             'BashSessionLexer', 'LiterateHaskellLexer', 'LiterateAgdaLexer',
             'PostgresConsoleLexer', 'ElixirConsoleLexer', 'JuliaConsoleLexer',
-            'RobotFrameworkLexer', 'DylanConsoleLexer', 'ShellSessionLexer'):
+            'RobotFrameworkLexer', 'DylanConsoleLexer', 'ShellSessionLexer',
+            'LiterateIdrisLexer', 'LiterateCryptolLexer'):
             inst = cls(ensurenl=False)
             ensure(inst.get_tokens('a\nb'), 'a\nb')
             inst = cls(ensurenl=False, stripall=True)
@@ -122,7 +129,7 @@ def test_get_lexers():
                        ]:
         yield verify, func, args
 
-    for cls, (_, lname, aliases, _, mimetypes) in lexers.LEXERS.iteritems():
+    for cls, (_, lname, aliases, _, mimetypes) in lexers.LEXERS.items():
         assert cls == lexers.find_lexer_class(lname).__name__
 
         for alias in aliases:
@@ -131,6 +138,13 @@ def test_get_lexers():
         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"))
@@ -157,7 +171,7 @@ def test_formatter_public_api():
             pass
         inst.format(ts, out)
 
-    for formatter, info in formatters.FORMATTERS.iteritems():
+    for formatter, info in formatters.FORMATTERS.items():
         yield verify, formatter, info
 
 def test_formatter_encodings():
@@ -167,7 +181,7 @@ def test_formatter_encodings():
     fmt = HtmlFormatter()
     tokens = [(Text, u"ä")]
     out = format(tokens, fmt)
-    assert type(out) is unicode
+    assert type(out) is text_type
     assert u"ä" in out
 
     # encoding option
@@ -196,7 +210,7 @@ def test_formatter_unicode_handling():
         if formatter.name != 'Raw tokens':
             out = format(tokens, inst)
             if formatter.unicodeoutput:
-                assert type(out) is unicode
+                assert type(out) is text_type
 
             inst = formatter(encoding='utf-8')
             out = format(tokens, inst)
@@ -208,7 +222,7 @@ def test_formatter_unicode_handling():
             out = format(tokens, inst)
             assert type(out) is bytes, '%s: %r' % (formatter, out)
 
-    for formatter, info in formatters.FORMATTERS.iteritems():
+    for formatter, info in formatters.FORMATTERS.items():
         yield verify, formatter
 
 
@@ -236,7 +250,7 @@ class FiltersTest(unittest.TestCase):
             'whitespace': {'spaces': True, 'tabs': True, 'newlines': True},
             'highlight': {'names': ['isinstance', 'lexers', 'x']},
         }
-        for x in filters.FILTERS.keys():
+        for x in filters.FILTERS:
             lx = lexers.PythonLexer()
             lx.add_filter(x, **filter_args.get(x, {}))
             fp = open(TESTFILE, 'rb')

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

@@ -0,0 +1,46 @@
+# -*- 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)))

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

@@ -3,14 +3,15 @@
     Basic CLexer Test
     ~~~~~~~~~~~~~~~~~
 
-    :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
+    :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
 import unittest
 import os
+import textwrap
 
-from pygments.token import Text, Number
+from pygments.token import Text, Number, Token
 from pygments.lexers import CLexer
 
 
@@ -27,5 +28,209 @@ class CLexerTest(unittest.TestCase):
                          Number.Float, Number.Float], code.split()):
             wanted.append(item)
             wanted.append((Text, ' '))
-        wanted = [(Text, '')] + wanted[:-1] + [(Text, '\n')]
+        wanted = wanted[:-1] + [(Text, '\n')]
         self.assertEqual(list(self.lexer.get_tokens(code)), wanted)
+
+    def testSwitch(self):
+        fragment = u'''\
+        int main()
+        {
+            switch (0)
+            {
+                case 0:
+                default:
+                    ;
+            }
+        }
+        '''
+        tokens = [
+            (Token.Keyword.Type, u'int'),
+            (Token.Text, u' '),
+            (Token.Name.Function, u'main'),
+            (Token.Punctuation, u'('),
+            (Token.Punctuation, u')'),
+            (Token.Text, u'\n'),
+            (Token.Punctuation, u'{'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'    '),
+            (Token.Keyword, u'switch'),
+            (Token.Text, u' '),
+            (Token.Punctuation, u'('),
+            (Token.Literal.Number.Integer, u'0'),
+            (Token.Punctuation, u')'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'    '),
+            (Token.Punctuation, u'{'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'        '),
+            (Token.Keyword, u'case'),
+            (Token.Text, u' '),
+            (Token.Literal.Number.Integer, u'0'),
+            (Token.Operator, u':'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'        '),
+            (Token.Keyword, u'default'),
+            (Token.Operator, u':'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'            '),
+            (Token.Punctuation, u';'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'    '),
+            (Token.Punctuation, u'}'),
+            (Token.Text, u'\n'),
+            (Token.Punctuation, u'}'),
+            (Token.Text, u'\n'),
+        ]
+        self.assertEqual(tokens, list(self.lexer.get_tokens(textwrap.dedent(fragment))))
+
+    def testSwitchSpaceBeforeColon(self):
+        fragment = u'''\
+        int main()
+        {
+            switch (0)
+            {
+                case 0 :
+                default :
+                    ;
+            }
+        }
+        '''
+        tokens = [
+            (Token.Keyword.Type, u'int'),
+            (Token.Text, u' '),
+            (Token.Name.Function, u'main'),
+            (Token.Punctuation, u'('),
+            (Token.Punctuation, u')'),
+            (Token.Text, u'\n'),
+            (Token.Punctuation, u'{'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'    '),
+            (Token.Keyword, u'switch'),
+            (Token.Text, u' '),
+            (Token.Punctuation, u'('),
+            (Token.Literal.Number.Integer, u'0'),
+            (Token.Punctuation, u')'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'    '),
+            (Token.Punctuation, u'{'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'        '),
+            (Token.Keyword, u'case'),
+            (Token.Text, u' '),
+            (Token.Literal.Number.Integer, u'0'),
+            (Token.Text, u' '),
+            (Token.Operator, u':'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'        '),
+            (Token.Keyword, u'default'),
+            (Token.Text, u' '),
+            (Token.Operator, u':'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'            '),
+            (Token.Punctuation, u';'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'    '),
+            (Token.Punctuation, u'}'),
+            (Token.Text, u'\n'),
+            (Token.Punctuation, u'}'),
+            (Token.Text, u'\n'),
+        ]
+        self.assertEqual(tokens, list(self.lexer.get_tokens(textwrap.dedent(fragment))))
+
+    def testLabel(self):
+        fragment = u'''\
+        int main()
+        {
+        foo:
+          goto foo;
+        }
+        '''
+        tokens = [
+            (Token.Keyword.Type, u'int'),
+            (Token.Text, u' '),
+            (Token.Name.Function, u'main'),
+            (Token.Punctuation, u'('),
+            (Token.Punctuation, u')'),
+            (Token.Text, u'\n'),
+            (Token.Punctuation, u'{'),
+            (Token.Text, u'\n'),
+            (Token.Name.Label, u'foo'),
+            (Token.Punctuation, u':'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'  '),
+            (Token.Keyword, u'goto'),
+            (Token.Text, u' '),
+            (Token.Name, u'foo'),
+            (Token.Punctuation, u';'),
+            (Token.Text, u'\n'),
+            (Token.Punctuation, u'}'),
+            (Token.Text, u'\n'),
+        ]
+        self.assertEqual(tokens, list(self.lexer.get_tokens(textwrap.dedent(fragment))))
+
+    def testLabelSpaceBeforeColon(self):
+        fragment = u'''\
+        int main()
+        {
+        foo :
+          goto foo;
+        }
+        '''
+        tokens = [
+            (Token.Keyword.Type, u'int'),
+            (Token.Text, u' '),
+            (Token.Name.Function, u'main'),
+            (Token.Punctuation, u'('),
+            (Token.Punctuation, u')'),
+            (Token.Text, u'\n'),
+            (Token.Punctuation, u'{'),
+            (Token.Text, u'\n'),
+            (Token.Name.Label, u'foo'),
+            (Token.Text, u' '),
+            (Token.Punctuation, u':'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'  '),
+            (Token.Keyword, u'goto'),
+            (Token.Text, u' '),
+            (Token.Name, u'foo'),
+            (Token.Punctuation, u';'),
+            (Token.Text, u'\n'),
+            (Token.Punctuation, u'}'),
+            (Token.Text, u'\n'),
+        ]
+        self.assertEqual(tokens, list(self.lexer.get_tokens(textwrap.dedent(fragment))))
+
+    def testLabelFollowedByStatement(self):
+        fragment = u'''\
+        int main()
+        {
+        foo:return 0;
+          goto foo;
+        }
+        '''
+        tokens = [
+            (Token.Keyword.Type, u'int'),
+            (Token.Text, u' '),
+            (Token.Name.Function, u'main'),
+            (Token.Punctuation, u'('),
+            (Token.Punctuation, u')'),
+            (Token.Text, u'\n'),
+            (Token.Punctuation, u'{'),
+            (Token.Text, u'\n'),
+            (Token.Name.Label, u'foo'),
+            (Token.Punctuation, u':'),
+            (Token.Keyword, u'return'),
+            (Token.Text, u' '),
+            (Token.Literal.Number.Integer, u'0'),
+            (Token.Punctuation, u';'),
+            (Token.Text, u'\n'),
+            (Token.Text, u'  '),
+            (Token.Keyword, u'goto'),
+            (Token.Text, u' '),
+            (Token.Name, u'foo'),
+            (Token.Punctuation, u';'),
+            (Token.Text, u'\n'),
+            (Token.Punctuation, u'}'),
+            (Token.Text, u'\n'),
+        ]
+        self.assertEqual(tokens, list(self.lexer.get_tokens(textwrap.dedent(fragment))))