From 7069245134db629eddcfb3f00f21f8ea7f9c2d97 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Mon, 10 Nov 2014 19:46:45 +0100
Subject: Add a -v command line switch that shows the full traceback.

---
 CHANGES               |  4 ++--
 pygments/cmdline.py   | 21 +++++++++++++++++++--
 tests/test_cmdline.py |  8 ++++++++
 3 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/CHANGES b/CHANGES
index 7031852e..92110efd 100644
--- a/CHANGES
+++ b/CHANGES
@@ -2,9 +2,9 @@ Pygments changelog
 ==================
 
 Issue numbers refer to the tracker at
-<http://bitbucket.org/birkenfeld/pygments-main/issues>,
+<https://bitbucket.org/birkenfeld/pygments-main/issues>,
 pull request numbers to the requests at
-<http://bitbucket.org/birkenfeld/pygments-main/pull-requests/merged>.
+<https://bitbucket.org/birkenfeld/pygments-main/pull-requests/merged>.
 
 
 Version 2.0.1
diff --git a/pygments/cmdline.py b/pygments/cmdline.py
index c3f00fca..04b50075 100644
--- a/pygments/cmdline.py
+++ b/pygments/cmdline.py
@@ -30,7 +30,7 @@ from pygments.styles import get_all_styles, get_style_by_name
 
 USAGE = """\
 Usage: %s [-l <lexer> | -g] [-F <filter>[:<options>]] [-f <formatter>]
-          [-O <options>] [-P <option=value>] [-s] [-o <outfile>] [<infile>]
+          [-O <options>] [-P <option=value>] [-s] [-v] [-o <outfile>] [<infile>]
 
        %s -S <style> -f <formatter> [-a <arg>] [-O <options>] [-P <option=value>]
        %s -L [<which> ...]
@@ -90,6 +90,9 @@ waiting to process the entire file.  This only works for stdin, and
 is intended for streaming input such as you get from 'tail -f'.
 Example usage: "tail -f sql.log | pygmentize -s -l sql"
 
+The -v option prints a detailed traceback on unhandled exceptions,
+which is useful for debugging and bug reports.
+
 The -h option prints this help.
 The -V option prints the package version.
 """
@@ -207,7 +210,7 @@ def main(args=sys.argv):
     usage = USAGE % ((args[0],) * 6)
 
     try:
-        popts, args = getopt.getopt(args[1:], "l:f:F:o:O:P:LS:a:N:hVHgs")
+        popts, args = getopt.getopt(args[1:], "l:f:F:o:O:P:LS:a:N:vhVHgs")
     except getopt.GetoptError:
         print(usage, file=sys.stderr)
         return 2
@@ -501,6 +504,18 @@ def main(args=sys.argv):
                 return 0
 
     except Exception:
+        if '-v' in opts:
+            print(file=sys.stderr)
+            print('*' * 65, file=sys.stderr)
+            print('An unhandled exception occurred while highlighting.',
+                  file=sys.stderr)
+            print('Please report the whole traceback to the issue tracker at',
+                  file=sys.stderr)
+            print('<https://bitbucket.org/birkenfeld/pygments-main/issues>.',
+                  file=sys.stderr)
+            print('*' * 65, file=sys.stderr)
+            print(file=sys.stderr)
+            raise
         import traceback
         info = traceback.format_exception(*sys.exc_info())
         msg = info[-1].strip()
@@ -510,6 +525,8 @@ def main(args=sys.argv):
         print(file=sys.stderr)
         print('*** Error while highlighting:', file=sys.stderr)
         print(msg, file=sys.stderr)
+        print('*** If this is a bug you want to report, please rerun with -v.',
+              file=sys.stderr)
         return 1
 
     return 0
diff --git a/tests/test_cmdline.py b/tests/test_cmdline.py
index d02d088a..5d05f32a 100644
--- a/tests/test_cmdline.py
+++ b/tests/test_cmdline.py
@@ -175,3 +175,11 @@ class CmdLineTest(unittest.TestCase):
         c, e = run_cmdline_with_closed_stdout('-lpython', TESTFILE)
         self.assertEqual(c, 1)
         self.assertIn('*** Error while highlighting:', e)
+
+        # same with -v: should reraise the exception
+        try:
+            run_cmdline_with_closed_stdout('-lpython', '-v', TESTFILE)
+        except Exception:
+            pass
+        else:
+            self.fail('exception not reraised')
-- 
cgit v1.2.1


From 2b79c4ef047c985b2a161401ace2c563f8b808da Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 08:59:17 +0100
Subject: default branch is 2.1a0.

---
 pygments/__init__.py | 2 +-
 setup.py             | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/pygments/__init__.py b/pygments/__init__.py
index 8170d5f0..1d8faebd 100644
--- a/pygments/__init__.py
+++ b/pygments/__init__.py
@@ -26,7 +26,7 @@
     :license: BSD, see LICENSE for details.
 """
 
-__version__ = '2.0.1'
+__version__ = '2.1a0'
 __docformat__ = 'restructuredtext'
 
 __all__ = ['lex', 'format', 'highlight']
diff --git a/setup.py b/setup.py
index c46d805e..36db0017 100755
--- a/setup.py
+++ b/setup.py
@@ -54,7 +54,7 @@ else:
 
 setup(
     name = 'Pygments',
-    version = '2.0.1',
+    version = '2.1a0',
     url = 'http://pygments.org/',
     license = 'BSD License',
     author = 'Georg Brandl',
-- 
cgit v1.2.1


From 3ee9b445c73f1ab4ad7be953adf8f229f2a8d76f Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 09:43:29 +0100
Subject: Bring pygments.cmdline coverage to ~100%, fix a few glitches in the
 process.

---
 pygments/cmdline.py   |  25 ++++----
 tests/test_cmdline.py | 175 +++++++++++++++++++++++++++++++++-----------------
 2 files changed, 126 insertions(+), 74 deletions(-)

diff --git a/pygments/cmdline.py b/pygments/cmdline.py
index 53e858b5..10b47f89 100644
--- a/pygments/cmdline.py
+++ b/pygments/cmdline.py
@@ -19,7 +19,7 @@ from pygments import __version__, highlight
 from pygments.util import ClassNotFound, OptionError, docstring_headline, \
     guess_decode, guess_decode_from_terminal, terminal_encoding
 from pygments.lexers import get_all_lexers, get_lexer_by_name, guess_lexer, \
-    get_lexer_for_filename, find_lexer_class, TextLexer
+    get_lexer_for_filename, find_lexer_class_for_filename, TextLexer
 from pygments.formatters.latex import LatexEmbeddedLexer, LatexFormatter
 from pygments.formatters import get_all_formatters, get_formatter_by_name, \
     get_formatter_for_filename, find_formatter_class, \
@@ -103,7 +103,7 @@ def _parse_options(o_strs):
     if not o_strs:
         return opts
     for o_str in o_strs:
-        if not o_str:
+        if not o_str.strip():
             continue
         o_args = o_str.split(',')
         for o_arg in o_args:
@@ -135,7 +135,7 @@ def _parse_filters(f_strs):
 def _print_help(what, name):
     try:
         if what == 'lexer':
-            cls = find_lexer_class(name)
+            cls = get_lexer_by_name(name)
             print("Help on the %s lexer:" % cls.name)
             print(dedent(cls.__doc__))
         elif what == 'formatter':
@@ -146,7 +146,7 @@ def _print_help(what, name):
             cls = find_filter_class(name)
             print("Help on the %s filter:" % name)
             print(dedent(cls.__doc__))
-    except AttributeError:
+    except (AttributeError, ValueError):
         print("%s not found!" % what, file=sys.stderr)
 
 
@@ -274,13 +274,9 @@ def main_inner(popts, args, usage):
     # handle ``pygmentize -N``
     infn = opts.pop('-N', None)
     if infn is not None:
-        try:
-            lexer = get_lexer_for_filename(infn, **parsed_opts)
-        except ClassNotFound as err:
-            lexer = TextLexer()
-        except OptionError as err:
-            print('Error:', err, file=sys.stderr)
-            return 1
+        lexer = find_lexer_class_for_filename(infn)
+        if lexer is None:
+            lexer = TextLexer
 
         print(lexer.aliases[0])
         return 0
@@ -432,7 +428,7 @@ def main_inner(popts, args, usage):
 
     # provide coloring under Windows, if possible
     if not outfn and sys.platform in ('win32', 'cygwin') and \
-       fmter.name in ('Terminal', 'Terminal256'):
+       fmter.name in ('Terminal', 'Terminal256'):  # pragma: no cover
         # unfortunately colorama doesn't support binary streams on Py3
         if sys.version_info > (3,):
             import io
@@ -472,7 +468,7 @@ def main_inner(popts, args, usage):
         if not lexer:
             print('Error: when using -s a lexer has to be selected with -l',
                   file=sys.stderr)
-            return 1
+            return 2
         # line by line processing of stdin (eg: for 'tail -f')...
         try:
             while 1:
@@ -488,7 +484,8 @@ def main_inner(popts, args, usage):
                 highlight(line, lexer, fmter, outfile)
                 if hasattr(outfile, 'flush'):
                     outfile.flush()
-        except KeyboardInterrupt:
+            return 0
+        except KeyboardInterrupt:  # pragma: no cover
             return 0
 
 
diff --git a/tests/test_cmdline.py b/tests/test_cmdline.py
index 8929ce0a..cf935152 100644
--- a/tests/test_cmdline.py
+++ b/tests/test_cmdline.py
@@ -11,32 +11,44 @@ from __future__ import print_function
 
 import io
 import os
+import re
 import sys
 import tempfile
 import unittest
 
-from pygments import highlight, cmdline
-from pygments.util import StringIO, BytesIO
-
 import support
+from pygments import cmdline, highlight
+from pygments.util import BytesIO, StringIO
+
 
 TESTFILE, TESTDIR = support.location(__file__)
+TESTCODE = '''\
+def func(args):
+    pass
+'''
 
 
-def run_cmdline(*args):
+def run_cmdline(*args, **kwds):
+    saved_stdin = sys.stdin
     saved_stdout = sys.stdout
     saved_stderr = sys.stderr
     if sys.version_info > (3,):
+        stdin_buffer = BytesIO()
         stdout_buffer = BytesIO()
         stderr_buffer = BytesIO()
+        new_stdin = sys.stdin = io.TextIOWrapper(stdin_buffer, 'utf-8')
         new_stdout = sys.stdout = io.TextIOWrapper(stdout_buffer, 'utf-8')
         new_stderr = sys.stderr = io.TextIOWrapper(stderr_buffer, 'utf-8')
     else:
+        stdin_buffer = new_stdin = sys.stdin = StringIO()
         stdout_buffer = new_stdout = sys.stdout = StringIO()
         stderr_buffer = new_stderr = sys.stderr = StringIO()
+    new_stdin.write(kwds.get('stdin', ''))
+    new_stdin.seek(0, 0)
     try:
         ret = cmdline.main(["pygmentize"] + list(args))
     finally:
+        sys.stdin = saved_stdin
         sys.stdout = saved_stdout
         sys.stderr = saved_stderr
     new_stdout.flush()
@@ -48,88 +60,127 @@ def run_cmdline(*args):
 
 class CmdLineTest(unittest.TestCase):
 
+    def check_success(self, *cmdline, **kwds):
+        code, out, err = run_cmdline(*cmdline, **kwds)
+        self.assertEqual(code, 0)
+        self.assertEqual(err, '')
+        return out
+
+    def check_failure(self, *cmdline, **kwds):
+        expected_code = kwds.pop('code', 1)
+        code, out, err = run_cmdline(*cmdline, **kwds)
+        self.assertEqual(code, expected_code)
+        self.assertEqual(out, '')
+        return err
+
+    def test_normal(self):
+        # test that cmdline gives the same output as library api
+        from pygments.lexers import PythonLexer
+        from pygments.formatters import HtmlFormatter
+        filename = TESTFILE
+        with open(filename, 'rb') as fp:
+            code = fp.read()
+
+        output = highlight(code, PythonLexer(), HtmlFormatter())
+
+        o = self.check_success("-lpython", "-fhtml", filename)
+        self.assertEqual(o, output)
+
+    def test_stdin(self):
+        o = self.check_success('-lpython', '-fhtml', stdin=TESTCODE)
+        o = re.sub('<[^>]*>', '', o)
+        # rstrip is necessary since HTML inserts a \n after the last </div>
+        self.assertEqual(o.rstrip(), TESTCODE.rstrip())
+
+        # guess if no lexer given
+        o = self.check_success('-fhtml', stdin=TESTCODE)
+        o = re.sub('<[^>]*>', '', o)
+        # rstrip is necessary since HTML inserts a \n after the last </div>
+        self.assertEqual(o.rstrip(), TESTCODE.rstrip())
+
+    def test_outfile(self):
+        # test that output file works with and without encoding
+        fd, name = tempfile.mkstemp()
+        os.close(fd)
+        for opts in [['-fhtml', '-o', name, TESTFILE],
+                     ['-flatex', '-o', name, TESTFILE],
+                     ['-fhtml', '-o', name, '-O', 'encoding=utf-8', TESTFILE]]:
+            try:
+                self.check_success(*opts)
+            finally:
+                os.unlink(name)
+
+    def test_stream_opt(self):
+        o = self.check_success('-lpython', '-s', '-fterminal', stdin=TESTCODE)
+        o = re.sub(r'\x1b\[.*?m', '', o)
+        self.assertEqual(o, TESTCODE)
+
     def test_L_opt(self):
-        c, o, e = run_cmdline("-L")
-        self.assertEqual(c, 0)
+        o = self.check_success("-L")
         self.assertTrue("Lexers" in o and "Formatters" in o and
                         "Filters" in o and "Styles" in o)
-        c, o, e = run_cmdline("-L", "lexer")
-        self.assertEqual(c, 0)
+        o = self.check_success("-L", "lexer")
         self.assertTrue("Lexers" in o and "Formatters" not in o)
-        c, o, e = run_cmdline("-L", "lexers")
-        self.assertEqual(c, 0)
+        self.check_success("-L", "lexers")
 
     def test_O_opt(self):
         filename = TESTFILE
-        c, o, e = run_cmdline("-Ofull=1,linenos=true,foo=bar",
-                              "-fhtml", filename)
-        self.assertEqual(c, 0)
+        o = self.check_success("-Ofull=1,linenos=true,foo=bar",
+                               "-fhtml", filename)
         self.assertTrue("<html" in o)
         self.assertTrue('class="linenos"' in o)
 
+        # "foobar" is invalid for a bool option
+        e = self.check_failure("-Ostripnl=foobar", TESTFILE)
+        self.assertTrue('Error: Invalid value' in e)
+        e = self.check_failure("-Ostripnl=foobar", "-lpy")
+        self.assertTrue('Error: Invalid value' in e)
+
     def test_P_opt(self):
         filename = TESTFILE
-        c, o, e = run_cmdline("-Pfull", "-Ptitle=foo, bar=baz=,",
-                              "-fhtml", filename)
-        self.assertEqual(c, 0)
+        o = self.check_success("-Pfull", "-Ptitle=foo, bar=baz=,",
+                               "-fhtml", filename)
         self.assertTrue("<title>foo, bar=baz=,</title>" in o)
 
     def test_F_opt(self):
         filename = TESTFILE
-        c, o, e = run_cmdline("-Fhighlight:tokentype=Name.Blubb,"
-                              "names=TESTFILE filename",
-                              "-fhtml", filename)
-        self.assertEqual(c, 0)
+        o = self.check_success("-Fhighlight:tokentype=Name.Blubb,"
+                               "names=TESTFILE filename",
+                               "-fhtml", filename)
         self.assertTrue('<span class="n-Blubb' in o)
 
     def test_H_opt(self):
-        c, o, e = run_cmdline("-H", "formatter", "html")
-        self.assertEqual(c, 0)
+        o = self.check_success("-H", "formatter", "html")
         self.assertTrue('HTML' in o)
+        o = self.check_success("-H", "lexer", "python")
+        self.assertTrue('Python' in o)
+        o = self.check_success("-H", "filter", "raiseonerror")
+        self.assertTrue('raiseonerror', o)
 
     def test_S_opt(self):
-        c, o, e = run_cmdline("-S", "default", "-f", "html", "-O", "linenos=1")
-        self.assertEqual(c, 0)
+        o = self.check_success("-S", "default", "-f", "html", "-O", "linenos=1")
+        lines = o.splitlines()
+        for line in lines:
+            # every line is for a token class
+            parts = line.split()
+            self.assertTrue(parts[0].startswith('.'))
+            self.assertTrue(parts[1] == '{')
+            if parts[0] != '.hll':
+                self.assertTrue(parts[-4] == '}')
+                self.assertTrue(parts[-3] == '/*')
+                self.assertTrue(parts[-1] == '*/')
+
+    def test_N_opt(self):
+        o = self.check_success("-N", "test.py")
+        self.assertEqual('python\n', o)
+        o = self.check_success("-N", "test.unknown")
+        self.assertEqual('text\n', o)
 
     def test_invalid_opts(self):
         for opts in [("-L", "-lpy"), ("-L", "-fhtml"), ("-L", "-Ox"),
                      ("-a",), ("-Sst", "-lpy"), ("-H",),
-                     ("-H", "formatter")]:
-            self.assertTrue(run_cmdline(*opts)[0] == 2)
-
-    def test_normal(self):
-        # test that cmdline gives the same output as library api
-        from pygments.lexers import PythonLexer
-        from pygments.formatters import HtmlFormatter
-        filename = TESTFILE
-        with open(filename, 'rb') as fp:
-            code = fp.read()
-
-        output = highlight(code, PythonLexer(), HtmlFormatter())
-
-        c, o, e = run_cmdline("-lpython", "-fhtml", filename)
-
-        self.assertEqual(o, output)
-        self.assertEqual(e, "")
-        self.assertEqual(c, 0)
-
-    def test_outfile(self):
-        # test that output file works with and without encoding
-        fd, name = tempfile.mkstemp()
-        os.close(fd)
-        for opts in [['-fhtml', '-o', name, TESTFILE],
-                     ['-flatex', '-o', name, TESTFILE],
-                     ['-fhtml', '-o', name, '-O', 'encoding=utf-8', TESTFILE]]:
-            try:
-                self.assertEqual(run_cmdline(*opts)[0], 0)
-            finally:
-                os.unlink(name)
-
-    def check_failure(self, *cmdline):
-        c, o, e = run_cmdline(*cmdline)
-        self.assertEqual(c, 1)
-        self.assertEqual(o, '')
-        return e
+                     ("-H", "formatter"), ("-H", "foo", "bar"), ("-s",)]:
+            self.check_failure(*opts, code=2)
 
     def test_errors(self):
         # input file not found
@@ -172,3 +223,7 @@ class CmdLineTest(unittest.TestCase):
                 self.fail('exception not reraised')
         finally:
             cmdline.highlight = highlight
+
+    def test_parse_opts(self):
+        self.assertEqual(cmdline._parse_options(['  ', 'keyonly,key = value ']),
+                         {'keyonly': True, 'key': 'value'})
-- 
cgit v1.2.1


From 3fcd14a2436594338146b6665fabebbc6bdb3f3d Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 10:00:06 +0100
Subject: Do not import pygments prematurely when running with coverage.

---
 tests/run.py | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/tests/run.py b/tests/run.py
index 94d629e8..c54e0bfa 100644
--- a/tests/run.py
+++ b/tests/run.py
@@ -28,18 +28,23 @@ 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)
+# make sure the current source is first on sys.path
+sys.path.insert(0, '..')
+
+if '--with-coverage' not in sys.argv:
+    # if running with coverage, pygments should not be imported before coverage
+    # is started, otherwise it will count already executed lines as uncovered
+    try:
+        import pygments
+    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]),
+              file=sys.stderr)
 else:
-    print('Pygments %s test suite running (Python %s)...' %
-          (pygments.__version__, sys.version.split()[0]))
+    print('Pygments test suite running (Python %s)...' % sys.version.split()[0],
+          file=sys.stderr)
 
 nose.main()
-- 
cgit v1.2.1


From e274c81a7e953c2988db97fb7dca3896c0e80bea Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 10:03:28 +0100
Subject: util: PEP8

---
 pygments/util.py | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/pygments/util.py b/pygments/util.py
index 9f683c0e..b5e5d0b6 100644
--- a/pygments/util.py
+++ b/pygments/util.py
@@ -55,7 +55,7 @@ def get_bool_opt(options, optname, default=None):
     elif not isinstance(string, string_types):
         raise OptionError('Invalid type %r for option %s; use '
                           '1/0, yes/no, true/false, on/off' % (
-                          string, optname))
+                              string, optname))
     elif string.lower() in ('1', 'yes', 'true', 'on'):
         return True
     elif string.lower() in ('0', 'no', 'false', 'off'):
@@ -63,7 +63,7 @@ def get_bool_opt(options, optname, default=None):
     else:
         raise OptionError('Invalid value %r for option %s; use '
                           '1/0, yes/no, true/false, on/off' % (
-                          string, optname))
+                              string, optname))
 
 
 def get_int_opt(options, optname, default=None):
@@ -73,11 +73,11 @@ def get_int_opt(options, optname, default=None):
     except TypeError:
         raise OptionError('Invalid type %r for option %s; you '
                           'must give an integer value' % (
-                          string, optname))
+                              string, optname))
     except ValueError:
         raise OptionError('Invalid value %r for option %s; you '
                           'must give an integer value' % (
-                          string, optname))
+                              string, optname))
 
 
 def get_list_opt(options, optname, default=None):
@@ -89,7 +89,7 @@ def get_list_opt(options, optname, default=None):
     else:
         raise OptionError('Invalid type %r for option %s; you '
                           'must give a list value' % (
-                          val, optname))
+                              val, optname))
 
 
 def docstring_headline(obj):
@@ -185,6 +185,8 @@ def html_doctype_matches(text):
 
 
 _looks_like_xml_cache = {}
+
+
 def looks_like_xml(text):
     """Check if a doctype exists or if we have some tags."""
     if xml_decl_re.match(text):
@@ -200,6 +202,7 @@ def looks_like_xml(text):
         _looks_like_xml_cache[key] = rv
         return rv
 
+
 # Python narrow build compatibility
 
 def _surrogatepair(c):
@@ -210,6 +213,7 @@ def _surrogatepair(c):
     # http://www.unicode.org/book/ch03.pdf
     return (0xd7c0 + (c >> 10), (0xdc00 + (c & 0x3ff)))
 
+
 def unirange(a, b):
     """Returns a regular expression string to match the given non-BMP range."""
     if b < a:
@@ -350,7 +354,8 @@ if sys.version_info < (3, 0):
     u_prefix = 'u'
     iteritems = dict.iteritems
     itervalues = dict.itervalues
-    import StringIO, cStringIO
+    import StringIO
+    import cStringIO
     # unfortunately, io.StringIO in Python 2 doesn't accept str at all
     StringIO = StringIO.StringIO
     BytesIO = cStringIO.StringIO
-- 
cgit v1.2.1


From 958498ae786cb99087fc0a9a085c8fc4aca9918c Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 10:03:41 +0100
Subject: More test coverage for pygments.console

---
 tests/test_util.py | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/tests/test_util.py b/tests/test_util.py
index e480b503..d6ebd51d 100644
--- a/tests/test_util.py
+++ b/tests/test_util.py
@@ -10,7 +10,7 @@
 import re
 import unittest
 
-from pygments import util
+from pygments import util, console
 
 
 class FakeLexer(object):
@@ -40,7 +40,6 @@ class UtilTest(unittest.TestCase):
         equals(util.get_list_opt({}, 'a', '1 2'), ['1', '2'])
         raises(util.OptionError, util.get_list_opt, {}, 'a', 1)
 
-
     def test_docstring_headline(self):
         def f1():
             """
@@ -157,3 +156,20 @@ class UtilTest(unittest.TestCase):
         # keeps first
         x = util.duplicates_removed(('a', 'b', 'a'))
         self.assertEqual(['a', 'b'], x)
+
+
+class ConsoleTest(unittest.TestCase):
+
+    def test_ansiformat(self):
+        f = console.ansiformat
+        c = console.codes
+        all_attrs = f('+*_blue_*+', 'text')
+        self.assertTrue(c['blue'] in all_attrs and c['blink'] in all_attrs
+                        and c['bold'] in all_attrs and c['underline'] in all_attrs
+                        and c['reset'] in all_attrs)
+        self.assertRaises(KeyError, f, '*mauve*', 'text')
+
+    def test_functions(self):
+        self.assertEqual(console.reset_color(), console.codes['reset'])
+        self.assertEqual(console.colorize('blue', 'text'),
+                         console.codes['blue'] + 'text' + console.codes['reset'])
-- 
cgit v1.2.1


From 15f0c0409888d5fb148e9eb9d20c340acd73d4ea Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 18:13:21 +0100
Subject: Use detailed exceptions with nose.

---
 Makefile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index a5741ffa..65ce0769 100644
--- a/Makefile
+++ b/Makefile
@@ -50,7 +50,7 @@ reindent:
 	@$(PYTHON) scripts/reindent.py -r -B .
 
 test:
-	@$(PYTHON) tests/run.py $(TEST)
+	@$(PYTHON) tests/run.py -d $(TEST)
 
 test-coverage:
-	@$(PYTHON) tests/run.py --with-coverage --cover-package=pygments $(TEST)
+	@$(PYTHON) tests/run.py -d --with-coverage --cover-package=pygments $(TEST)
-- 
cgit v1.2.1


From 59f4e88549ddd1fa1ea010fa6f65efb0ef344dc4 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 18:35:55 +0100
Subject: Reorder logic in cmdline.main a bit.

---
 pygments/cmdline.py | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/pygments/cmdline.py b/pygments/cmdline.py
index 10b47f89..0dcda7ae 100644
--- a/pygments/cmdline.py
+++ b/pygments/cmdline.py
@@ -386,6 +386,20 @@ def main_inner(popts, args, usage):
             except ClassNotFound:
                 lexer = TextLexer(**parsed_opts)
 
+    else:  # -s option needs a lexer with -l
+        if not lexer:
+            print('Error: when using -s a lexer has to be selected with -l',
+                  file=sys.stderr)
+            return 2
+
+    # process filters
+    for fname, fopts in F_opts:
+        try:
+            lexer.add_filter(fname, **fopts)
+        except ClassNotFound as err:
+            print('Error:', err, file=sys.stderr)
+            return 1
+
     # select formatter
     outfn = opts.pop('-o', None)
     fmter = opts.pop('-f', None)
@@ -451,24 +465,12 @@ def main_inner(popts, args, usage):
         right = escapeinside[1]
         lexer = LatexEmbeddedLexer(left, right, lexer)
 
-    # process filters
-    for fname, fopts in F_opts:
-        try:
-            lexer.add_filter(fname, **fopts)
-        except ClassNotFound as err:
-            print('Error:', err, file=sys.stderr)
-            return 1
-
     # ... and do it!
     if '-s' not in opts:
         # process whole input as per normal...
         highlight(code, lexer, fmter, outfile)
         return 0
     else:
-        if not lexer:
-            print('Error: when using -s a lexer has to be selected with -l',
-                  file=sys.stderr)
-            return 2
         # line by line processing of stdin (eg: for 'tail -f')...
         try:
             while 1:
-- 
cgit v1.2.1


From cbe1e3e5132dceeb96b57195579567d49928c00e Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 18:36:28 +0100
Subject: (Hopefully) fix test_cmdline failures under Windows without colorama.

---
 pygments/cmdline.py | 4 ++--
 pygments/util.py    | 7 ++++++-
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/pygments/cmdline.py b/pygments/cmdline.py
index 0dcda7ae..40c1a599 100644
--- a/pygments/cmdline.py
+++ b/pygments/cmdline.py
@@ -445,8 +445,8 @@ def main_inner(popts, args, usage):
        fmter.name in ('Terminal', 'Terminal256'):  # pragma: no cover
         # unfortunately colorama doesn't support binary streams on Py3
         if sys.version_info > (3,):
-            import io
-            outfile = io.TextIOWrapper(outfile, encoding=fmter.encoding)
+            from pygments.util import UnclosingTextIOWrapper
+            outfile = UnclosingTextIOWrapper(outfile, encoding=fmter.encoding)
             fmter.encoding = None
         try:
             import colorama.initialise
diff --git a/pygments/util.py b/pygments/util.py
index b5e5d0b6..22fab2fe 100644
--- a/pygments/util.py
+++ b/pygments/util.py
@@ -367,7 +367,12 @@ else:
     u_prefix = ''
     iteritems = dict.items
     itervalues = dict.values
-    from io import StringIO, BytesIO
+    from io import StringIO, BytesIO, TextIOWrapper
+
+    class UnclosingTextIOWrapper(TextIOWrapper):
+        # Don't close underlying buffer on destruction.
+        def close(self):
+            pass
 
 
 def add_metaclass(metaclass):
-- 
cgit v1.2.1


From de76526dbd90f0ff8c511de9cd24a6887e3bf90d Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 18:38:10 +0100
Subject: Fix and test the "lex(class)" and "format(class)" handlers.

---
 pygments/__init__.py    |  9 +++++----
 tests/test_basic_api.py | 19 ++++++++++++++++++-
 2 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/pygments/__init__.py b/pygments/__init__.py
index 1d8faebd..c1ea2af4 100644
--- a/pygments/__init__.py
+++ b/pygments/__init__.py
@@ -45,7 +45,8 @@ def lex(code, lexer):
         return lexer.get_tokens(code)
     except TypeError as err:
         if isinstance(err.args[0], str) and \
-           'unbound method get_tokens' in err.args[0]:
+           ('unbound method get_tokens' in err.args[0] or
+                'missing 1 required positional argument' in err.args[0]):
             raise TypeError('lex() argument must be a lexer instance, '
                             'not a class')
         raise
@@ -61,15 +62,15 @@ def format(tokens, formatter, outfile=None):
     """
     try:
         if not outfile:
-            #print formatter, 'using', formatter.encoding
-            realoutfile = formatter.encoding and BytesIO() or StringIO()
+            realoutfile = getattr(formatter, 'encoding', None) and BytesIO() or StringIO()
             formatter.format(tokens, realoutfile)
             return realoutfile.getvalue()
         else:
             formatter.format(tokens, outfile)
     except TypeError as err:
         if isinstance(err.args[0], str) and \
-           'unbound method format' in err.args[0]:
+           ('unbound method format' in err.args[0] or
+                'missing 1 required positional argument' in err.args[0]):
             raise TypeError('format() argument must be a formatter instance, '
                             'not a class')
         raise
diff --git a/tests/test_basic_api.py b/tests/test_basic_api.py
index 7485df1a..84dd49bb 100644
--- a/tests/test_basic_api.py
+++ b/tests/test_basic_api.py
@@ -12,7 +12,7 @@ from __future__ import print_function
 import random
 import unittest
 
-from pygments import lexers, formatters, filters, format
+from pygments import lexers, formatters, lex, format
 from pygments.token import _TokenType, Text
 from pygments.lexer import RegexLexer
 from pygments.formatters.img import FontNotFound
@@ -254,6 +254,23 @@ def test_styles():
     HtmlFormatter(style="pastie")
 
 
+def test_bare_class_handler():
+    from pygments.formatters import HtmlFormatter
+    from pygments.lexers import PythonLexer
+    try:
+        lex('test\n', PythonLexer)
+    except TypeError as e:
+        assert 'lex() argument must be a lexer instance' in str(e)
+    else:
+        assert False, 'nothing raised'
+    try:
+        format([], HtmlFormatter)
+    except TypeError as e:
+        assert 'format() argument must be a formatter instance' in str(e)
+    else:
+        assert False, 'nothing raised'
+
+
 class FiltersTest(unittest.TestCase):
 
     def test_basic(self):
-- 
cgit v1.2.1


From 6ef0dc9af1f4343f9574a589058cb6d0fa01b8d8 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 19:04:21 +0100
Subject: Care for Windows newlines in stdout.

---
 tests/test_cmdline.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/test_cmdline.py b/tests/test_cmdline.py
index cf935152..e7014418 100644
--- a/tests/test_cmdline.py
+++ b/tests/test_cmdline.py
@@ -113,7 +113,7 @@ class CmdLineTest(unittest.TestCase):
     def test_stream_opt(self):
         o = self.check_success('-lpython', '-s', '-fterminal', stdin=TESTCODE)
         o = re.sub(r'\x1b\[.*?m', '', o)
-        self.assertEqual(o, TESTCODE)
+        self.assertEqual(o.replace('\r\n', '\n'), TESTCODE)
 
     def test_L_opt(self):
         o = self.check_success("-L")
@@ -172,9 +172,9 @@ class CmdLineTest(unittest.TestCase):
 
     def test_N_opt(self):
         o = self.check_success("-N", "test.py")
-        self.assertEqual('python\n', o)
+        self.assertEqual('python', o.strip())
         o = self.check_success("-N", "test.unknown")
-        self.assertEqual('text\n', o)
+        self.assertEqual('text', o.strip())
 
     def test_invalid_opts(self):
         for opts in [("-L", "-lpy"), ("-L", "-fhtml"), ("-L", "-Ox"),
-- 
cgit v1.2.1


From 7ea9ac3db778e05fe2655018ca2fc5736c837489 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 19:14:13 +0100
Subject: Fix -H return codes and test them.

---
 pygments/cmdline.py   | 5 +++--
 tests/test_cmdline.py | 4 +++-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/pygments/cmdline.py b/pygments/cmdline.py
index 40c1a599..608bd859 100644
--- a/pygments/cmdline.py
+++ b/pygments/cmdline.py
@@ -146,8 +146,10 @@ def _print_help(what, name):
             cls = find_filter_class(name)
             print("Help on the %s filter:" % name)
             print(dedent(cls.__doc__))
+        return 0
     except (AttributeError, ValueError):
         print("%s not found!" % what, file=sys.stderr)
+        return 1
 
 
 def _print_list(what):
@@ -250,8 +252,7 @@ def main_inner(popts, args, usage):
             print(usage, file=sys.stderr)
             return 2
 
-        _print_help(what, name)
-        return 0
+        return _print_help(what, name)
 
     # parse -O options
     parsed_opts = _parse_options(O_opts)
diff --git a/tests/test_cmdline.py b/tests/test_cmdline.py
index e7014418..f4c866a6 100644
--- a/tests/test_cmdline.py
+++ b/tests/test_cmdline.py
@@ -156,6 +156,8 @@ class CmdLineTest(unittest.TestCase):
         self.assertTrue('Python' in o)
         o = self.check_success("-H", "filter", "raiseonerror")
         self.assertTrue('raiseonerror', o)
+        e = self.check_failure("-H", "lexer", "foobar")
+        self.assertTrue('not found' in e)
 
     def test_S_opt(self):
         o = self.check_success("-S", "default", "-f", "html", "-O", "linenos=1")
@@ -178,7 +180,7 @@ class CmdLineTest(unittest.TestCase):
 
     def test_invalid_opts(self):
         for opts in [("-L", "-lpy"), ("-L", "-fhtml"), ("-L", "-Ox"),
-                     ("-a",), ("-Sst", "-lpy"), ("-H",),
+                     ("-a", "arg"), ("-Sst", "-lpy"), ("-H",),
                      ("-H", "formatter"), ("-H", "foo", "bar"), ("-s",)]:
             self.check_failure(*opts, code=2)
 
-- 
cgit v1.2.1


From c37f936452070c9d6f478ce91990f5cc241c86f5 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 19:28:12 +0100
Subject: cmdline: more coverage

---
 pygments/cmdline.py   |  9 ++-------
 tests/test_cmdline.py | 29 +++++++++++++++++++++++++----
 2 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/pygments/cmdline.py b/pygments/cmdline.py
index 608bd859..9d6742a3 100644
--- a/pygments/cmdline.py
+++ b/pygments/cmdline.py
@@ -301,12 +301,7 @@ def main_inner(popts, args, usage):
             print(err, file=sys.stderr)
             return 1
 
-        arg = a_opt or ''
-        try:
-            print(fmter.get_style_defs(arg))
-        except Exception as err:
-            print('Error:', err, file=sys.stderr)
-            return 1
+        print(fmter.get_style_defs(a_opt or ''))
         return 0
 
     # if no -S is given, -a is not allowed
@@ -341,7 +336,7 @@ def main_inner(popts, args, usage):
         if '-s' in opts:
             print('Error: -s option not usable when input file specified',
                   file=sys.stderr)
-            return 1
+            return 2
 
         infn = args[0]
         try:
diff --git a/tests/test_cmdline.py b/tests/test_cmdline.py
index f4c866a6..bbb6c88c 100644
--- a/tests/test_cmdline.py
+++ b/tests/test_cmdline.py
@@ -115,6 +115,10 @@ class CmdLineTest(unittest.TestCase):
         o = re.sub(r'\x1b\[.*?m', '', o)
         self.assertEqual(o.replace('\r\n', '\n'), TESTCODE)
 
+    def test_h_opt(self):
+        o = self.check_success("-h")
+        self.assertTrue('Usage:' in o)
+
     def test_L_opt(self):
         o = self.check_success("-L")
         self.assertTrue("Lexers" in o and "Formatters" in o and
@@ -160,7 +164,7 @@ class CmdLineTest(unittest.TestCase):
         self.assertTrue('not found' in e)
 
     def test_S_opt(self):
-        o = self.check_success("-S", "default", "-f", "html", "-O", "linenos=1")
+        o = self.check_success('-S', 'default', '-f', 'html', '-O', 'linenos=1')
         lines = o.splitlines()
         for line in lines:
             # every line is for a token class
@@ -171,6 +175,7 @@ class CmdLineTest(unittest.TestCase):
                 self.assertTrue(parts[-4] == '}')
                 self.assertTrue(parts[-3] == '/*')
                 self.assertTrue(parts[-1] == '*/')
+        self.check_failure('-S', 'default', '-f', 'foobar')
 
     def test_N_opt(self):
         o = self.check_success("-N", "test.py")
@@ -179,9 +184,21 @@ class CmdLineTest(unittest.TestCase):
         self.assertEqual('text', o.strip())
 
     def test_invalid_opts(self):
-        for opts in [("-L", "-lpy"), ("-L", "-fhtml"), ("-L", "-Ox"),
-                     ("-a", "arg"), ("-Sst", "-lpy"), ("-H",),
-                     ("-H", "formatter"), ("-H", "foo", "bar"), ("-s",)]:
+        for opts in [
+            ('-X',),
+            ('-L', '-lpy'),
+            ('-L', '-fhtml'),
+            ('-L', '-Ox'),
+            ('-S', 'default', '-l', 'py', '-f', 'html'),
+            ('-S', 'default'),
+            ('-a', 'arg'),
+            ('-H',),
+            (TESTFILE, TESTFILE),
+            ('-H', 'formatter'),
+            ('-H', 'foo', 'bar'),
+            ('-s',),
+            ('-s', TESTFILE),
+        ]:
             self.check_failure(*opts, code=2)
 
     def test_errors(self):
@@ -198,6 +215,10 @@ class CmdLineTest(unittest.TestCase):
         e = self.check_failure('-lpython', '-ffoo', TESTFILE)
         self.assertTrue('Error: no formatter found for name' in e)
 
+        # formatter for outfile not found
+        e = self.check_failure('-ofoo.foo', TESTFILE)
+        self.assertTrue('Error: no formatter found for file name' in e)
+
         # output file not writable
         e = self.check_failure('-o', os.path.join('nonexistent', 'dir', 'out.html'),
                                '-lpython', TESTFILE)
-- 
cgit v1.2.1


From 6449543ebb434d613ee6d3a57ea9cc527b7aeeef Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 19:23:39 +0100
Subject: Quote normalization.

---
 tests/test_cmdline.py | 52 +++++++++++++++++++++++++--------------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/tests/test_cmdline.py b/tests/test_cmdline.py
index bbb6c88c..da6b2bec 100644
--- a/tests/test_cmdline.py
+++ b/tests/test_cmdline.py
@@ -46,7 +46,7 @@ def run_cmdline(*args, **kwds):
     new_stdin.write(kwds.get('stdin', ''))
     new_stdin.seek(0, 0)
     try:
-        ret = cmdline.main(["pygmentize"] + list(args))
+        ret = cmdline.main(['pygmentize'] + list(args))
     finally:
         sys.stdin = saved_stdin
         sys.stdout = saved_stdout
@@ -83,7 +83,7 @@ class CmdLineTest(unittest.TestCase):
 
         output = highlight(code, PythonLexer(), HtmlFormatter())
 
-        o = self.check_success("-lpython", "-fhtml", filename)
+        o = self.check_success('-lpython', '-fhtml', filename)
         self.assertEqual(o, output)
 
     def test_stdin(self):
@@ -116,51 +116,51 @@ class CmdLineTest(unittest.TestCase):
         self.assertEqual(o.replace('\r\n', '\n'), TESTCODE)
 
     def test_h_opt(self):
-        o = self.check_success("-h")
+        o = self.check_success('-h')
         self.assertTrue('Usage:' in o)
 
     def test_L_opt(self):
-        o = self.check_success("-L")
-        self.assertTrue("Lexers" in o and "Formatters" in o and
-                        "Filters" in o and "Styles" in o)
-        o = self.check_success("-L", "lexer")
-        self.assertTrue("Lexers" in o and "Formatters" not in o)
-        self.check_success("-L", "lexers")
+        o = self.check_success('-L')
+        self.assertTrue('Lexers' in o and 'Formatters' in o and
+                        'Filters' in o and 'Styles' in o)
+        o = self.check_success('-L', 'lexer')
+        self.assertTrue('Lexers' in o and 'Formatters' not in o)
+        self.check_success('-L', 'lexers')
 
     def test_O_opt(self):
         filename = TESTFILE
-        o = self.check_success("-Ofull=1,linenos=true,foo=bar",
-                               "-fhtml", filename)
-        self.assertTrue("<html" in o)
+        o = self.check_success('-Ofull=1,linenos=true,foo=bar',
+                               '-fhtml', filename)
+        self.assertTrue('<html' in o)
         self.assertTrue('class="linenos"' in o)
 
         # "foobar" is invalid for a bool option
-        e = self.check_failure("-Ostripnl=foobar", TESTFILE)
+        e = self.check_failure('-Ostripnl=foobar', TESTFILE)
         self.assertTrue('Error: Invalid value' in e)
-        e = self.check_failure("-Ostripnl=foobar", "-lpy")
+        e = self.check_failure('-Ostripnl=foobar', '-lpy')
         self.assertTrue('Error: Invalid value' in e)
 
     def test_P_opt(self):
         filename = TESTFILE
-        o = self.check_success("-Pfull", "-Ptitle=foo, bar=baz=,",
-                               "-fhtml", filename)
-        self.assertTrue("<title>foo, bar=baz=,</title>" in o)
+        o = self.check_success('-Pfull', '-Ptitle=foo, bar=baz=,',
+                               '-fhtml', filename)
+        self.assertTrue('<title>foo, bar=baz=,</title>' in o)
 
     def test_F_opt(self):
         filename = TESTFILE
-        o = self.check_success("-Fhighlight:tokentype=Name.Blubb,"
-                               "names=TESTFILE filename",
-                               "-fhtml", filename)
+        o = self.check_success('-Fhighlight:tokentype=Name.Blubb,'
+                               'names=TESTFILE filename',
+                               '-fhtml', filename)
         self.assertTrue('<span class="n-Blubb' in o)
 
     def test_H_opt(self):
-        o = self.check_success("-H", "formatter", "html")
+        o = self.check_success('-H', 'formatter', 'html')
         self.assertTrue('HTML' in o)
-        o = self.check_success("-H", "lexer", "python")
+        o = self.check_success('-H', 'lexer', 'python')
         self.assertTrue('Python' in o)
-        o = self.check_success("-H", "filter", "raiseonerror")
+        o = self.check_success('-H', 'filter', 'raiseonerror')
         self.assertTrue('raiseonerror', o)
-        e = self.check_failure("-H", "lexer", "foobar")
+        e = self.check_failure('-H', 'lexer', 'foobar')
         self.assertTrue('not found' in e)
 
     def test_S_opt(self):
@@ -178,9 +178,9 @@ class CmdLineTest(unittest.TestCase):
         self.check_failure('-S', 'default', '-f', 'foobar')
 
     def test_N_opt(self):
-        o = self.check_success("-N", "test.py")
+        o = self.check_success('-N', 'test.py')
         self.assertEqual('python', o.strip())
-        o = self.check_success("-N", "test.unknown")
+        o = self.check_success('-N', 'test.unknown')
         self.assertEqual('text', o.strip())
 
     def test_invalid_opts(self):
-- 
cgit v1.2.1


From 543b3cb13bbafa81805b039fe955e60794b4ae5e Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 19:40:50 +0100
Subject: More coverage of newer HTML formatter options.

---
 pygments/formatters/html.py  | 12 +-----------
 tests/test_html_formatter.py | 27 ++++++++++++++++++++++-----
 2 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/pygments/formatters/html.py b/pygments/formatters/html.py
index 2c6de4ca..f15edc7e 100644
--- a/pygments/formatters/html.py
+++ b/pygments/formatters/html.py
@@ -36,21 +36,11 @@ _escape_html_table = {
     ord("'"): u'&#39;',
 }
 
+
 def escape_html(text, table=_escape_html_table):
     """Escape &, <, > as well as single and double quotes for HTML."""
     return text.translate(table)
 
-def get_random_id():
-    """Return a random id for javascript fields."""
-    from random import random
-    from time import time
-    try:
-        from hashlib import sha1 as sha
-    except ImportError:
-        import sha
-        sha = sha.new
-    return sha('%s|%s' % (random(), time())).hexdigest()
-
 
 def _get_ttype_class(ttype):
     fname = STANDARD_TYPES.get(ttype)
diff --git a/tests/test_html_formatter.py b/tests/test_html_formatter.py
index 5b1b2576..92a0415b 100644
--- a/tests/test_html_formatter.py
+++ b/tests/test_html_formatter.py
@@ -68,15 +68,32 @@ class HtmlFormatterTest(unittest.TestCase):
             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)]:
-
+        def check(optdict):
             outfile = StringIO()
             fmt = HtmlFormatter(**optdict)
             fmt.format(tokensource, outfile)
 
+        for optdict in [
+            dict(nowrap=True),
+            dict(linenos=True, full=True),
+            dict(linenos=True, linespans='L'),
+            dict(hl_lines=[1, 5, 10, 'xxx']),
+            dict(hl_lines=[1, 5, 10], noclasses=True),
+        ]:
+            check(optdict)
+
+        for linenos in [False, 'table', 'inline']:
+            for noclasses in [False, True]:
+                for linenospecial in [0, 5]:
+                    for anchorlinenos in [False, True]:
+                        optdict = dict(
+                            linenos=linenos,
+                            noclasses=noclasses,
+                            linenospecial=linenospecial,
+                            anchorlinenos=anchorlinenos,
+                        )
+                        check(optdict)
+
     def test_linenos(self):
         optdict = dict(linenos=True)
         outfile = StringIO()
-- 
cgit v1.2.1


From 6b6c5bfbdaf2239aec62d436da135c8f8e02f44a Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Tue, 11 Nov 2014 19:56:09 +0100
Subject: Add more coverage for pygments.util.

---
 tests/test_util.py | 50 ++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 44 insertions(+), 6 deletions(-)

diff --git a/tests/test_util.py b/tests/test_util.py
index d6ebd51d..695fb7d2 100644
--- a/tests/test_util.py
+++ b/tests/test_util.py
@@ -15,7 +15,7 @@ from pygments import util, console
 
 class FakeLexer(object):
     def analyse(text):
-        return float(text)
+        return text
     analyse = util.make_analysator(analyse)
 
 
@@ -40,6 +40,11 @@ class UtilTest(unittest.TestCase):
         equals(util.get_list_opt({}, 'a', '1 2'), ['1', '2'])
         raises(util.OptionError, util.get_list_opt, {}, 'a', 1)
 
+        equals(util.get_choice_opt({}, 'a', ['foo', 'bar'], 'bar'), 'bar')
+        equals(util.get_choice_opt({}, 'a', ['foo', 'bar'], 'Bar', True), 'bar')
+        raises(util.OptionError, util.get_choice_opt, {}, 'a',
+               ['foo', 'bar'], 'baz')
+
     def test_docstring_headline(self):
         def f1():
             """
@@ -54,9 +59,12 @@ class UtilTest(unittest.TestCase):
 
             other text
             """
+        def f3():
+            pass
 
-        self.assertEqual(util.docstring_headline(f1), "docstring headline")
-        self.assertEqual(util.docstring_headline(f2), "docstring headline")
+        self.assertEqual(util.docstring_headline(f1), 'docstring headline')
+        self.assertEqual(util.docstring_headline(f2), 'docstring headline')
+        self.assertEqual(util.docstring_headline(f3), '')
 
     def test_analysator_returns_float(self):
         # If an analysator wrapped by make_analysator returns a floating point
@@ -87,10 +95,10 @@ class UtilTest(unittest.TestCase):
     def test_analysator_type_error(self):
         # When converting the analysator's return value to a float a
         # TypeError may occur.  If that happens 0.0 is returned instead.
-        self.assertEqual(FakeLexer.analyse(None), 0.0)
+        self.assertEqual(FakeLexer.analyse('xxx'), 0.0)
 
     def test_shebang_matches(self):
-        self.assertTrue(util.shebang_matches('#!/usr/bin/env python', r'python(2\.\d)?'))
+        self.assertTrue(util.shebang_matches('#!/usr/bin/env python\n', r'python(2\.\d)?'))
         self.assertTrue(util.shebang_matches('#!/usr/bin/python2.4', r'python(2\.\d)?'))
         self.assertTrue(util.shebang_matches('#!/usr/bin/startsomethingwith python',
                                              r'python(2\.\d)?'))
@@ -105,7 +113,7 @@ class UtilTest(unittest.TestCase):
 
     def test_doctype_matches(self):
         self.assertTrue(util.doctype_matches(
-            '<!DOCTYPE html PUBLIC "a"> <html>', 'html.*'))
+            '<!DOCTYPE html> <html>', 'html.*'))
         self.assertFalse(util.doctype_matches(
             '<?xml ?> <DOCTYPE html PUBLIC "a"> <html>', 'html.*'))
         self.assertTrue(util.html_doctype_matches(
@@ -157,6 +165,36 @@ class UtilTest(unittest.TestCase):
         x = util.duplicates_removed(('a', 'b', 'a'))
         self.assertEqual(['a', 'b'], x)
 
+    def test_guess_decode(self):
+        # UTF-8 should be decoded as UTF-8
+        s = util.guess_decode(u'\xff'.encode('utf-8'))
+        self.assertEqual(s, (u'\xff', 'utf-8'))
+
+        # otherwise, it could be latin1 or the locale encoding...
+        import locale
+        s = util.guess_decode(b'\xff')
+        self.assertTrue(s[1] in ('latin1', locale.getpreferredencoding()))
+
+    def test_guess_decode_from_terminal(self):
+        class Term:
+            encoding = 'utf-7'
+
+        s = util.guess_decode_from_terminal(u'\xff'.encode('utf-7'), Term)
+        self.assertEqual(s, (u'\xff', 'utf-7'))
+
+        s = util.guess_decode_from_terminal(u'\xff'.encode('utf-8'), Term)
+        self.assertEqual(s, (u'\xff', 'utf-8'))
+
+    def test_add_metaclass(self):
+        class Meta(type):
+            pass
+
+        @util.add_metaclass(Meta)
+        class Cls:
+            pass
+
+        self.assertEqual(type(Cls), Meta)
+
 
 class ConsoleTest(unittest.TestCase):
 
-- 
cgit v1.2.1


From 153905b11a1043fbf8d6f6de39407c123134ff35 Mon Sep 17 00:00:00 2001
From: Michal ?iha? <michal@cihar.com>
Date: Thu, 13 Nov 2014 08:58:01 +0100
Subject: Add msgctxt keyword to Gettext PO lexer

---
 pygments/lexers/textfmts.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pygments/lexers/textfmts.py b/pygments/lexers/textfmts.py
index 189d334a..b37421a2 100644
--- a/pygments/lexers/textfmts.py
+++ b/pygments/lexers/textfmts.py
@@ -102,7 +102,7 @@ class GettextLexer(RegexLexer):
             (r'^(")([A-Za-z-]+:)(.*")$',
              bygroups(String, Name.Property, String)),
             (r'^".*"$', String),
-            (r'^(msgid|msgid_plural|msgstr)(\s+)(".*")$',
+            (r'^(msgid|msgid_plural|msgstr|msgctxt)(\s+)(".*")$',
              bygroups(Name.Variable, Text, String)),
             (r'^(msgstr\[)(\d)(\])(\s+)(".*")$',
              bygroups(Name.Variable, Number.Integer, Name.Variable, Text, String)),
-- 
cgit v1.2.1


From 6fbfecd5d1075293973210453b116a4a60461a23 Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Thu, 13 Nov 2014 14:30:41 +0100
Subject: latex: small code cleanup

---
 pygments/formatters/latex.py | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/pygments/formatters/latex.py b/pygments/formatters/latex.py
index 7a4eeca8..bc8b07e1 100644
--- a/pygments/formatters/latex.py
+++ b/pygments/formatters/latex.py
@@ -360,7 +360,7 @@ class LatexFormatter(Formatter):
                         start += value[i]
 
                     value = value[len(start):]
-                    start = escape_tex(start, self.commandprefix)
+                    start = escape_tex(start, cp)
 
                     # ... but do not escape inside comment.
                     value = start + value
@@ -370,26 +370,26 @@ class LatexFormatter(Formatter):
                     in_math = False
                     for i, part in enumerate(parts):
                         if not in_math:
-                            parts[i] = escape_tex(part, self.commandprefix)
+                            parts[i] = escape_tex(part, cp)
                         in_math = not in_math
                     value = '$'.join(parts)
                 elif self.escapeinside:
                     text = value
                     value = ''
-                    while len(text) > 0:
+                    while text:
                         a, sep1, text = text.partition(self.left)
-                        if len(sep1) > 0:
+                        if sep1:
                             b, sep2, text = text.partition(self.right)
-                            if len(sep2) > 0:
-                                value += escape_tex(a, self.commandprefix) + b
+                            if sep2:
+                                value += escape_tex(a, cp) + b
                             else:
-                                value += escape_tex(a + sep1 + b, self.commandprefix)
+                                value += escape_tex(a + sep1 + b, cp)
                         else:
-                            value = value + escape_tex(a, self.commandprefix)
+                            value += escape_tex(a, cp)
                 else:
-                    value = escape_tex(value, self.commandprefix)
+                    value = escape_tex(value, cp)
             elif ttype not in Token.Escape:
-                value = escape_tex(value, self.commandprefix)
+                value = escape_tex(value, cp)
             styles = []
             while ttype is not Token:
                 try:
@@ -423,8 +423,7 @@ class LatexFormatter(Formatter):
 
 
 class LatexEmbeddedLexer(Lexer):
-    r"""
-
+    """
     This lexer takes one lexer as argument, the lexer for the language
     being formatted, and the left and right delimiters for escaped text.
 
-- 
cgit v1.2.1


From 4550ef568a25ba93afec4ec82e7b2a6e2d70470d Mon Sep 17 00:00:00 2001
From: "Jeffrey B. Arnold" <jeffrey.arnold@gmail.com>
Date: Fri, 14 Nov 2014 04:44:13 -0800
Subject: updated Stan lexer to language version 2.5.0

---
 pygments/lexers/_stan_builtins.py | 53 +++++++++++++++++++++++----------------
 pygments/lexers/modeling.py       |  4 +--
 2 files changed, 34 insertions(+), 23 deletions(-)

diff --git a/pygments/lexers/_stan_builtins.py b/pygments/lexers/_stan_builtins.py
index 246cdd88..f9e331d3 100644
--- a/pygments/lexers/_stan_builtins.py
+++ b/pygments/lexers/_stan_builtins.py
@@ -4,26 +4,25 @@
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     This file contains the names of functions for Stan used by
-    ``pygments.lexers.math.StanLexer. This is for Stan language version 2.4.0.
+    ``pygments.lexers.math.StanLexer. This is for Stan language version 2.5.0.
 
     :copyright: Copyright 2006-2014 by the Pygments team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
 
-KEYWORDS = (
-    'else',
+KEYWORDS = (   'else',
     'for',
     'if',
     'in',
     'increment_log_prob',
+    'integrate_ode',
     'lp__',
     'print',
+    'reject',
     'return',
-    'while',
-)
+    'while')
 
-TYPES = (
-    'cholesky_factor_corr',
+TYPES = (   'cholesky_factor_corr',
     'cholesky_factor_cov',
     'corr_matrix',
     'cov_matrix',
@@ -36,15 +35,15 @@ TYPES = (
     'simplex',
     'unit_vector',
     'vector',
-    'void',
-)
+    'void')
 
-FUNCTIONS = (
-    'Phi',
+FUNCTIONS = (   'Phi',
     'Phi_approx',
     'abs',
     'acos',
     'acosh',
+    'append_col',
+    'append_row',
     'asin',
     'asinh',
     'atan',
@@ -144,6 +143,11 @@ FUNCTIONS = (
     'fmax',
     'fmin',
     'fmod',
+    'frechet_ccdf_log',
+    'frechet_cdf',
+    'frechet_cdf_log',
+    'frechet_log',
+    'frechet_rng',
     'gamma_ccdf_log',
     'gamma_cdf',
     'gamma_cdf_log',
@@ -152,6 +156,7 @@ FUNCTIONS = (
     'gamma_q',
     'gamma_rng',
     'gaussian_dlm_obs_log',
+    'get_lp',
     'gumbel_ccdf_log',
     'gumbel_cdf',
     'gumbel_cdf_log',
@@ -182,6 +187,8 @@ FUNCTIONS = (
     'inv_wishart_rng',
     'inverse',
     'inverse_spd',
+    'is_inf',
+    'is_nan',
     'lbeta',
     'lgamma',
     'lkj_corr_cholesky_log',
@@ -252,6 +259,7 @@ FUNCTIONS = (
     'normal_log',
     'normal_rng',
     'not_a_number',
+    'num_elements',
     'ordered_logistic_log',
     'ordered_logistic_rng',
     'owens_t',
@@ -260,6 +268,11 @@ FUNCTIONS = (
     'pareto_cdf_log',
     'pareto_log',
     'pareto_rng',
+    'pareto_type_2_ccdf_log',
+    'pareto_type_2_cdf',
+    'pareto_type_2_cdf_log',
+    'pareto_type_2_log',
+    'pareto_type_2_rng',
     'pi',
     'poisson_ccdf_log',
     'poisson_cdf',
@@ -354,11 +367,9 @@ FUNCTIONS = (
     'weibull_log',
     'weibull_rng',
     'wishart_log',
-    'wishart_rng',
-)
+    'wishart_rng')
 
-DISTRIBUTIONS = (
-    'bernoulli',
+DISTRIBUTIONS = (   'bernoulli',
     'bernoulli_logit',
     'beta',
     'beta_binomial',
@@ -372,6 +383,7 @@ DISTRIBUTIONS = (
     'double_exponential',
     'exp_mod_normal',
     'exponential',
+    'frechet',
     'gamma',
     'gaussian_dlm_obs',
     'gumbel',
@@ -396,6 +408,7 @@ DISTRIBUTIONS = (
     'normal',
     'ordered_logistic',
     'pareto',
+    'pareto_type_2',
     'poisson',
     'poisson_log',
     'rayleigh',
@@ -405,11 +418,9 @@ DISTRIBUTIONS = (
     'uniform',
     'von_mises',
     'weibull',
-    'wishart',
-)
+    'wishart')
 
-RESERVED = (
-    'alignas',
+RESERVED = (   'alignas',
     'alignof',
     'and',
     'and_eq',
@@ -494,5 +505,5 @@ RESERVED = (
     'volatile',
     'wchar_t',
     'xor',
-    'xor_eq',
-)
+    'xor_eq')
+
diff --git a/pygments/lexers/modeling.py b/pygments/lexers/modeling.py
index 1552fbf8..c3bf5208 100644
--- a/pygments/lexers/modeling.py
+++ b/pygments/lexers/modeling.py
@@ -284,8 +284,8 @@ class StanLexer(RegexLexer):
     """Pygments Lexer for Stan models.
 
     The Stan modeling language is specified in the *Stan Modeling Language
-    User's Guide and Reference Manual, v2.4.0*,
-    `pdf <https://github.com/stan-dev/stan/releases/download/v2.4.0/stan-reference-2.4.0.pdf>`__.
+    User's Guide and Reference Manual, v2.5.0*,
+    `pdf <https://github.com/stan-dev/stan/releases/download/v2.5.0/stan-reference-2.5.0.pdf>`__.
 
     .. versionadded:: 1.6
     """
-- 
cgit v1.2.1


From 98d148ee687fc47769e938cadbea4c4bc9312cdf Mon Sep 17 00:00:00 2001
From: EricFromCanada <eric3knibbe@gmail.com>
Date: Fri, 14 Nov 2014 09:49:37 -0500
Subject: fix display of short names & filenames on Formatters page

---
 pygments/sphinxext.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pygments/sphinxext.py b/pygments/sphinxext.py
index 82bc6543..85a434ad 100644
--- a/pygments/sphinxext.py
+++ b/pygments/sphinxext.py
@@ -133,8 +133,8 @@ class PygmentsDoc(Directive):
             if isinstance(docstring, bytes):
                 docstring = docstring.decode('utf8')
             heading = cls.__name__
-            out.append(FMTERDOC % (heading, ', '.join(data[1]) or 'None',
-                                   ', '.join(data[2]).replace('*', '\\*') or 'None',
+            out.append(FMTERDOC % (heading, ', '.join(data[2]) or 'None',
+                                   ', '.join(data[3]).replace('*', '\\*') or 'None',
                                    docstring))
         return ''.join(out)
 
-- 
cgit v1.2.1


From 16d1f837af5ab4b9b4826854efff2b1f6685542d Mon Sep 17 00:00:00 2001
From: EricFromCanada <eric3knibbe@gmail.com>
Date: Fri, 14 Nov 2014 09:51:30 -0500
Subject: spelling/grammar/syntax fixes for docs

---
 doc/docs/filterdevelopment.rst |  2 +-
 doc/docs/java.rst              | 14 +++++++-------
 doc/docs/lexerdevelopment.rst  |  8 ++++----
 doc/docs/lexers.rst            |  2 +-
 doc/docs/tokens.rst            |  4 ++--
 doc/docs/unicode.rst           |  2 +-
 doc/languages.rst              |  7 ++++---
 pygments/lexers/console.py     |  2 +-
 pygments/lexers/dotnet.py      |  4 ++--
 pygments/lexers/javascript.py  |  2 +-
 pygments/lexers/templates.py   |  8 ++++----
 11 files changed, 28 insertions(+), 27 deletions(-)

diff --git a/doc/docs/filterdevelopment.rst b/doc/docs/filterdevelopment.rst
index bc399a6f..5f9ca8c7 100644
--- a/doc/docs/filterdevelopment.rst
+++ b/doc/docs/filterdevelopment.rst
@@ -8,7 +8,7 @@ Write your own filter
 
 Writing own filters is very easy. All you have to do is to subclass
 the `Filter` class and override the `filter` method. Additionally a
-filter is instanciated with some keyword arguments you can use to
+filter is instantiated with some keyword arguments you can use to
 adjust the behavior of your filter.
 
 
diff --git a/doc/docs/java.rst b/doc/docs/java.rst
index 5eb6196a..f553463c 100644
--- a/doc/docs/java.rst
+++ b/doc/docs/java.rst
@@ -2,18 +2,18 @@
 Use Pygments in Java
 =====================
 
-Thanks to `Jython <http://www.jython.org>`__ it is possible to use Pygments in
+Thanks to `Jython <http://www.jython.org>`_ it is possible to use Pygments in
 Java.
 
-This page is a simple tutorial to get an idea of how this is working. You can
-then look at the `Jython documentation <http://www.jython.org/docs/>`__ for more
-advanced use.
+This page is a simple tutorial to get an idea of how this works. You can
+then look at the `Jython documentation <http://www.jython.org/docs/>`_ for more
+advanced uses.
 
 Since version 1.5, Pygments is deployed on `Maven Central
-<http://repo1.maven.org/maven2/org/pygments/pygments/>`__ as a JAR so is Jython
-which makes it a lot easier to create the Java project.
+<http://repo1.maven.org/maven2/org/pygments/pygments/>`_ as a JAR, as is Jython
+which makes it a lot easier to create a Java project.
 
-Here is an example of a `Maven <http://www.maven.org>`__ ``pom.xml`` file for a
+Here is an example of a `Maven <http://www.maven.org>`_ ``pom.xml`` file for a
 project running Pygments:
 
 .. sourcecode:: xml
diff --git a/doc/docs/lexerdevelopment.rst b/doc/docs/lexerdevelopment.rst
index 23bcb4f7..08069889 100644
--- a/doc/docs/lexerdevelopment.rst
+++ b/doc/docs/lexerdevelopment.rst
@@ -88,10 +88,10 @@ one.
 Adding and testing a new lexer
 ==============================
 
-To make pygments aware of your new lexer, you have to perform the following
+To make Pygments aware of your new lexer, you have to perform the following
 steps:
 
-First, change to the current directory containing the pygments source code:
+First, change to the current directory containing the Pygments source code:
 
 .. code-block:: console
 
@@ -123,7 +123,7 @@ Now you can use pygmentize to render your example to HTML:
 
     $ ./pygmentize -O full -f html -o /tmp/example.html tests/examplefiles/example.diff
 
-Note that this explicitely calls the ``pygmentize`` in the current directory
+Note that this explicitly calls the ``pygmentize`` in the current directory
 by preceding it with ``./``. This ensures your modifications are used.
 Otherwise a possibly already installed, unmodified version without your new
 lexer would have been called from the system search path (``$PATH``).
@@ -239,7 +239,7 @@ output stream marked as `Comment.Multiline` and continues lexing with the rules
 defined in the ``'comment'`` state.
 
 If there wasn't an asterisk after the slash, the `RegexLexer` checks if it's a
-singleline comment (i.e. followed by a second slash).  If this also wasn't the
+Singleline comment (i.e. followed by a second slash).  If this also wasn't the
 case it must be a single slash, which is not a comment starter (the separate
 regex for a single slash must also be given, else the slash would be marked as
 an error token).
diff --git a/doc/docs/lexers.rst b/doc/docs/lexers.rst
index fefc940e..9262efb0 100644
--- a/doc/docs/lexers.rst
+++ b/doc/docs/lexers.rst
@@ -31,7 +31,7 @@ Currently, **all lexers** support these options:
 
     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 <http://chardet.feedparser.org/>`__ is used to
+    `chardet library <http://chardet.feedparser.org/>`_ is used to
     guess the encoding of the input.
 
     .. versionadded:: 0.6
diff --git a/doc/docs/tokens.rst b/doc/docs/tokens.rst
index 9193d5f4..194eb70f 100644
--- a/doc/docs/tokens.rst
+++ b/doc/docs/tokens.rst
@@ -89,7 +89,7 @@ The `is_token_subtype()` function in the `pygments.token` module can be used to
 test if a token type is a subtype of another (such as `Name.Tag` and `Name`).
 (This is the same as ``Name.Tag in Name``. The overloaded `in` operator was newly
 introduced in Pygments 0.7, the function still exists for backwards
-compatiblity.)
+compatibility.)
 
 With Pygments 0.7, it's also possible to convert strings to token types (for example
 if you want to supply a token from the command line):
@@ -160,7 +160,7 @@ Name Tokens
     other languages constants are uppercase by definition (Ruby).
 
 `Name.Decorator`
-    Token type for decorators. Decorators are synatic elements in the Python
+    Token type for decorators. Decorators are syntactic elements in the Python
     language. Similar syntax elements exist in C# and Java.
 
 `Name.Entity`
diff --git a/doc/docs/unicode.rst b/doc/docs/unicode.rst
index 7291a3b2..17853a36 100644
--- a/doc/docs/unicode.rst
+++ b/doc/docs/unicode.rst
@@ -18,7 +18,7 @@ data using this encoding.
 
 You can override the encoding using the `encoding` or `inencoding` lexer
 options.  If you have the `chardet`_ library installed and set the encoding to
-``chardet`` if will ananlyse the text and use the encoding it thinks is the
+``chardet`` if will analyse the text and use the encoding it thinks is the
 right one automatically:
 
 .. sourcecode:: python
diff --git a/doc/languages.rst b/doc/languages.rst
index 0f98c583..1d5c3155 100644
--- a/doc/languages.rst
+++ b/doc/languages.rst
@@ -27,7 +27,7 @@ Programming languages
 * Coq
 * Cryptol (incl. Literate Cryptol)
 * `Cython <http://cython.org>`_
-* `D <http://digitalmars.com/d>`_
+* `D <http://dlang.org>`_
 * Dart
 * Delphi
 * Dylan
@@ -45,6 +45,7 @@ Programming languages
 * Io
 * Java
 * JavaScript
+* Lasso
 * LLVM
 * Logtalk
 * `Lua <http://www.lua.org>`_
@@ -97,8 +98,8 @@ Template languages
 * `Genshi <http://genshi.edgewall.org>`_ (the Trac template language)
 * JSP (Java Server Pages)
 * `Myghty <http://www.myghty.org>`_ (the HTML::Mason based framework)
-* `Mako <http://www.makotemplates.org/>`_ (the Myghty successor)
-* `Smarty <http://smarty.php.net>`_ templates (PHP templating)
+* `Mako <http://www.makotemplates.org>`_ (the Myghty successor)
+* `Smarty <http://www.smarty.net>`_ templates (PHP templating)
 * Tea
 
 Other markup
diff --git a/pygments/lexers/console.py b/pygments/lexers/console.py
index 56120582..c76ed648 100644
--- a/pygments/lexers/console.py
+++ b/pygments/lexers/console.py
@@ -18,7 +18,7 @@ __all__ = ['VCTreeStatusLexer', 'PyPyLogLexer']
 
 class VCTreeStatusLexer(RegexLexer):
     """
-    For colorizing output of version control status commans, like "hg
+    For colorizing output of version control status commands, like "hg
     status" or "svn status".
 
     .. versionadded:: 2.0
diff --git a/pygments/lexers/dotnet.py b/pygments/lexers/dotnet.py
index d24f64ea..afdb7786 100644
--- a/pygments/lexers/dotnet.py
+++ b/pygments/lexers/dotnet.py
@@ -497,7 +497,7 @@ class GenericAspxLexer(RegexLexer):
 # TODO support multiple languages within the same source file
 class CSharpAspxLexer(DelegatingLexer):
     """
-    Lexer for highligting C# within ASP.NET pages.
+    Lexer for highlighting C# within ASP.NET pages.
     """
 
     name = 'aspx-cs'
@@ -518,7 +518,7 @@ class CSharpAspxLexer(DelegatingLexer):
 
 class VbNetAspxLexer(DelegatingLexer):
     """
-    Lexer for highligting Visual Basic.net within ASP.NET pages.
+    Lexer for highlighting Visual Basic.net within ASP.NET pages.
     """
 
     name = 'aspx-vb'
diff --git a/pygments/lexers/javascript.py b/pygments/lexers/javascript.py
index 404bcf96..8e258f9a 100644
--- a/pygments/lexers/javascript.py
+++ b/pygments/lexers/javascript.py
@@ -213,7 +213,7 @@ class LiveScriptLexer(RegexLexer):
 
     .. _LiveScript: http://gkz.github.com/LiveScript/
 
-    New in Pygments 1.6.
+    .. versionadded:: 1.6
     """
 
     name = 'LiveScript'
diff --git a/pygments/lexers/templates.py b/pygments/lexers/templates.py
index c153f513..b106523d 100644
--- a/pygments/lexers/templates.py
+++ b/pygments/lexers/templates.py
@@ -1122,7 +1122,7 @@ class HtmlPhpLexer(DelegatingLexer):
 
 class XmlPhpLexer(DelegatingLexer):
     """
-    Subclass of `PhpLexer` that higlights unhandled data with the `XmlLexer`.
+    Subclass of `PhpLexer` that highlights unhandled data with the `XmlLexer`.
     """
 
     name = 'XML+PHP'
@@ -1180,7 +1180,7 @@ class JavascriptPhpLexer(DelegatingLexer):
 
 class HtmlSmartyLexer(DelegatingLexer):
     """
-    Subclass of the `SmartyLexer` that highighlights unlexed data with the
+    Subclass of the `SmartyLexer` that highlights unlexed data with the
     `HtmlLexer`.
 
     Nested Javascript and CSS is highlighted too.
@@ -1263,7 +1263,7 @@ class JavascriptSmartyLexer(DelegatingLexer):
 
 class HtmlDjangoLexer(DelegatingLexer):
     """
-    Subclass of the `DjangoLexer` that highighlights unlexed data with the
+    Subclass of the `DjangoLexer` that highlights unlexed data with the
     `HtmlLexer`.
 
     Nested Javascript and CSS is highlighted too.
@@ -1851,7 +1851,7 @@ class HandlebarsHtmlLexer(DelegatingLexer):
 
 class YamlJinjaLexer(DelegatingLexer):
     """
-    Subclass of the `DjangoLexer` that highighlights unlexed data with the
+    Subclass of the `DjangoLexer` that highlights unlexed data with the
     `YamlLexer`.
 
     Commonly used in Saltstack salt states.
-- 
cgit v1.2.1


From fc5bf35d2c1b74fb0748687a0b7ffceb482f79c2 Mon Sep 17 00:00:00 2001
From: "Jeffrey B. Arnold" <jeffrey.arnold@gmail.com>
Date: Fri, 14 Nov 2014 20:04:39 -0800
Subject: adding reject statement to Stan example file

---
 pygments/lexers/_stan_builtins.py | 30 ++++++++++++++++++++----------
 tests/examplefiles/example.stan   |  3 +++
 2 files changed, 23 insertions(+), 10 deletions(-)

diff --git a/pygments/lexers/_stan_builtins.py b/pygments/lexers/_stan_builtins.py
index f9e331d3..fc2e1d71 100644
--- a/pygments/lexers/_stan_builtins.py
+++ b/pygments/lexers/_stan_builtins.py
@@ -10,7 +10,8 @@
     :license: BSD, see LICENSE for details.
 """
 
-KEYWORDS = (   'else',
+KEYWORDS = (
+    'else',
     'for',
     'if',
     'in',
@@ -20,9 +21,11 @@ KEYWORDS = (   'else',
     'print',
     'reject',
     'return',
-    'while')
+    'while'
+)
 
-TYPES = (   'cholesky_factor_corr',
+TYPES = (
+    'cholesky_factor_corr',
     'cholesky_factor_cov',
     'corr_matrix',
     'cov_matrix',
@@ -35,9 +38,11 @@ TYPES = (   'cholesky_factor_corr',
     'simplex',
     'unit_vector',
     'vector',
-    'void')
+    'void'
+)
 
-FUNCTIONS = (   'Phi',
+FUNCTIONS = (
+    'Phi',
     'Phi_approx',
     'abs',
     'acos',
@@ -367,9 +372,11 @@ FUNCTIONS = (   'Phi',
     'weibull_log',
     'weibull_rng',
     'wishart_log',
-    'wishart_rng')
+    'wishart_rng'
+)
 
-DISTRIBUTIONS = (   'bernoulli',
+DISTRIBUTIONS = (
+    'bernoulli',
     'bernoulli_logit',
     'beta',
     'beta_binomial',
@@ -418,9 +425,11 @@ DISTRIBUTIONS = (   'bernoulli',
     'uniform',
     'von_mises',
     'weibull',
-    'wishart')
+    'wishart'
+)
 
-RESERVED = (   'alignas',
+RESERVED = (
+    'alignas',
     'alignof',
     'and',
     'and_eq',
@@ -505,5 +514,6 @@ RESERVED = (   'alignas',
     'volatile',
     'wchar_t',
     'xor',
-    'xor_eq')
+    'xor_eq'
+)
 
diff --git a/tests/examplefiles/example.stan b/tests/examplefiles/example.stan
index 716b4d12..69c9ac70 100644
--- a/tests/examplefiles/example.stan
+++ b/tests/examplefiles/example.stan
@@ -111,6 +111,9 @@ model {
   print("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_~@#$%^&*`'-+={}[].,;: ");
   print("Hello, world!");
   print("");
+
+  // reject statement
+  reject("I just don't like it");
   
 }
 generated quantities {
-- 
cgit v1.2.1


From 9298be28bf6f934658a6facf2263542f7826c2ba Mon Sep 17 00:00:00 2001
From: Soonho Kong <soonhok@cs.cmu.edu>
Date: Mon, 24 Nov 2014 22:11:50 -0500
Subject: Add two missing operators '?' and '!' for Lean theorem prover

---
 pygments/lexers/theorem.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pygments/lexers/theorem.py b/pygments/lexers/theorem.py
index 585c6df9..fdd4fd81 100644
--- a/pygments/lexers/theorem.py
+++ b/pygments/lexers/theorem.py
@@ -416,11 +416,11 @@ class LeanLexer(RegexLexer):
     )
 
     operators = (
-        '!=', '#', '&', '&&', '*', '+', '-', '/', '@',
+        '!=', '#', '&', '&&', '*', '+', '-', '/', '@', '!',
         '-.', '->', '.', '..', '...', '::', ':>', ';', ';;', '<',
         '<-', '=', '==', '>', '_', '`', '|', '||', '~', '=>', '<=', '>=',
         '/\\', '\\/', u'∀', u'Π', u'λ', u'↔', u'∧', u'∨', u'≠', u'≤', u'≥',
-        u'¬', u'⁻¹', u'⬝', u'▸', u'→', u'∃', u'ℕ', u'ℤ', u'≈'
+        u'¬', u'⁻¹', u'⬝', u'▸', u'→', u'∃', u'ℕ', u'ℤ', u'≈', u'×'
     )
 
     word_operators = ('and', 'or', 'not', 'iff', 'eq')
-- 
cgit v1.2.1


From 1c2cda5b58d4a37b71e5f047cad5fe133463aec0 Mon Sep 17 00:00:00 2001
From: Soonho Kong <soonhok@cs.cmu.edu>
Date: Tue, 9 Dec 2014 03:39:44 -0500
Subject: Add a missing operator '`' for Lean theorem prover

---
 pygments/lexers/theorem.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pygments/lexers/theorem.py b/pygments/lexers/theorem.py
index fdd4fd81..b8b08b53 100644
--- a/pygments/lexers/theorem.py
+++ b/pygments/lexers/theorem.py
@@ -416,7 +416,7 @@ class LeanLexer(RegexLexer):
     )
 
     operators = (
-        '!=', '#', '&', '&&', '*', '+', '-', '/', '@', '!',
+        '!=', '#', '&', '&&', '*', '+', '-', '/', '@', '!', '`',
         '-.', '->', '.', '..', '...', '::', ':>', ';', ';;', '<',
         '<-', '=', '==', '>', '_', '`', '|', '||', '~', '=>', '<=', '>=',
         '/\\', '\\/', u'∀', u'Π', u'λ', u'↔', u'∧', u'∨', u'≠', u'≤', u'≥',
-- 
cgit v1.2.1


From 41e23d60dc516a22966325f97b7b00b448bd55a7 Mon Sep 17 00:00:00 2001
From: Soonho Kong <soonhok@cs.cmu.edu>
Date: Thu, 15 Jan 2015 16:37:45 +0900
Subject: Add three missing operators '?', '?', '?' for Lean theorem prover

---
 pygments/lexers/theorem.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pygments/lexers/theorem.py b/pygments/lexers/theorem.py
index b8b08b53..addf4186 100644
--- a/pygments/lexers/theorem.py
+++ b/pygments/lexers/theorem.py
@@ -420,7 +420,7 @@ class LeanLexer(RegexLexer):
         '-.', '->', '.', '..', '...', '::', ':>', ';', ';;', '<',
         '<-', '=', '==', '>', '_', '`', '|', '||', '~', '=>', '<=', '>=',
         '/\\', '\\/', u'∀', u'Π', u'λ', u'↔', u'∧', u'∨', u'≠', u'≤', u'≥',
-        u'¬', u'⁻¹', u'⬝', u'▸', u'→', u'∃', u'ℕ', u'ℤ', u'≈', u'×'
+        u'¬', u'⁻¹', u'⬝', u'▸', u'→', u'∃', u'ℕ', u'ℤ', u'≈', u'×', u'⌞', u'⌟', u'≡'
     )
 
     word_operators = ('and', 'or', 'not', 'iff', 'eq')
-- 
cgit v1.2.1


From f0fb7b24cb57727640f119c7497127c290549bd5 Mon Sep 17 00:00:00 2001
From: Soonho Kong <soonhok@cs.cmu.edu>
Date: Fri, 16 Jan 2015 07:49:39 +0900
Subject: remove tactics, word_operators, and primitives from highlighting

---
 pygments/lexers/theorem.py | 29 +++++++----------------------
 1 file changed, 7 insertions(+), 22 deletions(-)

diff --git a/pygments/lexers/theorem.py b/pygments/lexers/theorem.py
index addf4186..5b71bf97 100644
--- a/pygments/lexers/theorem.py
+++ b/pygments/lexers/theorem.py
@@ -395,11 +395,13 @@ class LeanLexer(RegexLexer):
                  'options', 'precedence', 'postfix', 'prefix', 'calc_trans', 'calc_subst', 'calc_refl',
                  'infix', 'infixl', 'infixr', 'notation', 'eval', 'check', 'exit', 'coercion', 'end',
                  'private', 'using', 'namespace', 'including', 'instance', 'section', 'context',
-                 'protected', 'expose', 'export', 'set_option', 'add_rewrite', 'extends')
+                 'protected', 'expose', 'export', 'set_option', 'add_rewrite', 'extends',
+                 'open', 'example', 'constant', 'constants', 'print', 'opaque', 'reducible', 'irreducible'
+    )
 
     keywords2 = (
-        'forall', 'exists', 'fun', 'Pi', 'obtain', 'from', 'have', 'show', 'assume', 'take',
-        'let', 'if', 'else', 'then', 'by', 'in', 'with', 'begin', 'proof', 'qed', 'calc'
+        'forall', 'fun', 'Pi', 'obtain', 'from', 'have', 'show', 'assume', 'take',
+        'let', 'if', 'else', 'then', 'by', 'in', 'with', 'begin', 'proof', 'qed', 'calc', 'match'
     )
 
     keywords3 = (
@@ -407,14 +409,6 @@ class LeanLexer(RegexLexer):
         'Type', 'Prop',
     )
 
-    keywords4 = (
-        # Tactics
-        'apply', 'and_then', 'or_else', 'append', 'interleave', 'par', 'fixpoint', 'repeat',
-        'at_most', 'discard', 'focus_at', 'rotate', 'try_for', 'now', 'assumption', 'eassumption',
-        'state', 'intro', 'generalize', 'exact', 'unfold', 'beta', 'trace', 'focus', 'repeat1',
-        'determ', 'destruct', 'try', 'auto', 'intros'
-    )
-
     operators = (
         '!=', '#', '&', '&&', '*', '+', '-', '/', '@', '!', '`',
         '-.', '->', '.', '..', '...', '::', ':>', ';', ';;', '<',
@@ -423,33 +417,24 @@ class LeanLexer(RegexLexer):
         u'¬', u'⁻¹', u'⬝', u'▸', u'→', u'∃', u'ℕ', u'ℤ', u'≈', u'×', u'⌞', u'⌟', u'≡'
     )
 
-    word_operators = ('and', 'or', 'not', 'iff', 'eq')
-
     punctuation = ('(', ')', ':', '{', '}', '[', ']', u'⦃', u'⦄', ':=', ',')
 
-    primitives = ('unit', 'int', 'bool', 'string', 'char', 'list',
-                  'array', 'prod', 'sum', 'pair', 'real', 'nat', 'num', 'path')
-
     tokens = {
         'root': [
             (r'\s+', Text),
-            (r'\b(false|true)\b|\(\)|\[\]', Name.Builtin.Pseudo),
             (r'/-', Comment, 'comment'),
             (r'--.*?$', Comment.Single),
             (words(keywords1, prefix=r'\b', suffix=r'\b'), Keyword.Namespace),
             (words(keywords2, prefix=r'\b', suffix=r'\b'), Keyword),
             (words(keywords3, prefix=r'\b', suffix=r'\b'), Keyword.Type),
-            (words(keywords4, prefix=r'\b', suffix=r'\b'), Keyword),
             (words(operators), Name.Builtin.Pseudo),
-            (words(word_operators, prefix=r'\b', suffix=r'\b'), Name.Builtin.Pseudo),
             (words(punctuation), Operator),
-            (words(primitives, prefix=r'\b', suffix=r'\b'), Keyword.Type),
             (u"[A-Za-z_\u03b1-\u03ba\u03bc-\u03fb\u1f00-\u1ffe\u2100-\u214f]"
              u"[A-Za-z_'\u03b1-\u03ba\u03bc-\u03fb\u1f00-\u1ffe\u2070-\u2079"
-             u"\u207f-\u2089\u2090-\u209c\u2100-\u214f]*", Name),
+             u"\u207f-\u2089\u2090-\u209c\u2100-\u214f0-9]*", Name),
             (r'\d+', Number.Integer),
             (r'"', String.Double, 'string'),
-            (r'[~?][a-z][\w\']*:', Name.Variable)
+            (r'[~?][A-z][\w\']*:', Name.Variable)
         ],
         'comment': [
             # Multiline Comments
-- 
cgit v1.2.1


From e776ca304cd6b2241dc15490cefbd275e87a574a Mon Sep 17 00:00:00 2001
From: Soonho Kong <soonhok@cs.cmu.edu>
Date: Fri, 16 Jan 2015 18:07:07 +0900
Subject: Rollback to [a-z] for the Name.Variable

---
 pygments/lexers/theorem.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pygments/lexers/theorem.py b/pygments/lexers/theorem.py
index 5b71bf97..b2a51dcf 100644
--- a/pygments/lexers/theorem.py
+++ b/pygments/lexers/theorem.py
@@ -434,7 +434,7 @@ class LeanLexer(RegexLexer):
              u"\u207f-\u2089\u2090-\u209c\u2100-\u214f0-9]*", Name),
             (r'\d+', Number.Integer),
             (r'"', String.Double, 'string'),
-            (r'[~?][A-z][\w\']*:', Name.Variable)
+            (r'[~?][a-z][\w\']*:', Name.Variable)
         ],
         'comment': [
             # Multiline Comments
-- 
cgit v1.2.1


From 181e8bff0a08fe2e31607991ef2c5b5b5d060f1b Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Wed, 21 Jan 2015 07:25:35 +0100
Subject: Closes #1075: fix docs for @simplefilter.

The function needs a "self" argument since it is used as a method in the
automatically created class.  No use fixing that in the code, as it
kills backwards compatibility.
---
 .hgignore                      | 1 +
 doc/docs/filterdevelopment.rst | 5 +++--
 pygments/filter.py             | 2 +-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/.hgignore b/.hgignore
index 509abffa..6fd21b49 100644
--- a/.hgignore
+++ b/.hgignore
@@ -10,5 +10,6 @@ Pygments.egg-info/*
 tests/examplefiles/output
 .idea/
 .tags
+TAGS
 tests/.coverage
 tests/cover
diff --git a/doc/docs/filterdevelopment.rst b/doc/docs/filterdevelopment.rst
index 5f9ca8c7..fbcd0a09 100644
--- a/doc/docs/filterdevelopment.rst
+++ b/doc/docs/filterdevelopment.rst
@@ -58,7 +58,7 @@ You can also use the `simplefilter` decorator from the `pygments.filter` module:
 
 
     @simplefilter
-    def uncolor(lexer, stream, options):
+    def uncolor(self, lexer, stream, options):
         class_too = get_bool_opt(options, 'classtoo')
         for ttype, value in stream:
             if ttype is Name.Function or (class_too and
@@ -67,4 +67,5 @@ You can also use the `simplefilter` decorator from the `pygments.filter` module:
             yield ttype, value
 
 The decorator automatically subclasses an internal filter class and uses the
-decorated function for filtering.
+decorated function as a method for filtering.  (That's why there is a `self`
+argument that you probably won't end up using in the method.)
diff --git a/pygments/filter.py b/pygments/filter.py
index 092ef331..12eb6f03 100644
--- a/pygments/filter.py
+++ b/pygments/filter.py
@@ -29,7 +29,7 @@ def simplefilter(f):
     Decorator that converts a function into a filter::
 
         @simplefilter
-        def lowercase(lexer, stream, options):
+        def lowercase(self, lexer, stream, options):
             for ttype, value in stream:
                 yield ttype, value.lower()
     """
-- 
cgit v1.2.1