gitlab-pygments.rb 0.3.2

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

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

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

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+"""
+    Pygments regex lexer tests
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    :copyright: Copyright 2006-2012 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import unittest
+
+from pygments.token import Text
+from pygments.lexer import RegexLexer
+from pygments.lexer import bygroups
+
+
+class TestLexer(RegexLexer):
+    """Test tuple state transitions including #pop."""
+    tokens = {
+        'root': [
+            ('a', Text.Root, 'rag'),
+            ('e', Text.Root),
+        ],
+        'beer': [
+            ('d', Text.Beer, ('#pop', '#pop')),
+        ],
+        'rag': [
+            ('b', Text.Rag, '#push'),
+            ('c', Text.Rag, ('#pop', 'beer')),
+        ],
+    }
+
+
+class TupleTransTest(unittest.TestCase):
+    def test(self):
+        lx = TestLexer()
+        toks = list(lx.get_tokens_unprocessed('abcde'))
+        self.assertEqual(toks,
+           [(0, Text.Root, 'a'), (1, Text.Rag, 'b'), (2, Text.Rag, 'c'),
+            (3, Text.Beer, 'd'), (4, Text.Root, 'e')])
+
+    def test_multiline(self):
+        lx = TestLexer()
+        toks = list(lx.get_tokens_unprocessed('a\ne'))
+        self.assertEqual(toks,
+           [(0, Text.Root, 'a'), (1, Text, u'\n'),
+            (2, Text.Root, 'e')])

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

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+"""
+    Test suite for the token module
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    :copyright: Copyright 2006-2012 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import unittest
+
+from pygments import token
+
+
+class TokenTest(unittest.TestCase):
+
+    def test_tokentype(self):
+        e = self.assertEqual
+
+        t = token.String
+
+        e(t.split(), [token.Token, token.Literal, token.String])
+
+        e(t.__class__, token._TokenType)
+
+    def test_functions(self):
+        self.assertTrue(token.is_token_subtype(token.String, token.String))
+        self.assertTrue(token.is_token_subtype(token.String, token.Literal))
+        self.assertFalse(token.is_token_subtype(token.Literal, token.String))
+
+        self.assertTrue(token.string_to_tokentype(token.String) is token.String)
+        self.assertTrue(token.string_to_tokentype('') is token.Token)
+        self.assertTrue(token.string_to_tokentype('String') is token.String)
+
+    def test_sanity_check(self):
+        stp = token.STANDARD_TYPES.copy()
+        stp[token.Token] = '---' # Token and Text do conflict, that is okay
+        t = {}
+        for k, v in stp.iteritems():
+            t.setdefault(v, []).append(k)
+        if len(t) == len(stp):
+            return # Okay
+
+        for k, v in t.iteritems():
+            if len(v) > 1:
+                self.fail("%r has more than one key: %r" % (k, v))

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

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+"""
+    Pygments tests for using()
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    :copyright: Copyright 2006-2012 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import unittest
+
+from pygments.lexer import using, bygroups, this, RegexLexer
+from pygments.token import String, Text, Keyword
+
+class TestLexer(RegexLexer):
+    tokens = {
+        'root': [
+            (r'#.*',
+             using(this, state='invalid')),
+            (r'(")(.+?)(")',
+             bygroups(String, using(this, state='string'), String)),
+            (r'[^"]+', Text),
+        ],
+        'string': [
+            (r'.+', Keyword),
+        ],
+    }
+
+
+class UsingStateTest(unittest.TestCase):
+    def test_basic(self):
+        expected = [(Text, 'a'), (String, '"'), (Keyword, 'bcd'),
+                    (String, '"'), (Text, 'e\n')]
+        t = list(TestLexer().get_tokens('a"bcd"e'))
+        self.assertEqual(t, expected)
+
+    def test_error(self):
+        def gen():
+            return list(TestLexer().get_tokens('#a'))
+        self.assertRaises(KeyError, gen)

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

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+"""
+    Test suite for the util module
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    :copyright: Copyright 2006-2012 by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+import unittest
+
+from pygments import util
+
+
+class FakeLexer(object):
+    def analyse(text):
+        return float(text)
+    analyse = util.make_analysator(analyse)
+
+
+class UtilTest(unittest.TestCase):
+
+    def test_getoptions(self):
+        raises = self.assertRaises
+        equals = self.assertEqual
+
+        equals(util.get_bool_opt({}, 'a', True), True)
+        equals(util.get_bool_opt({}, 'a', 1), True)
+        equals(util.get_bool_opt({}, 'a', 'true'), True)
+        equals(util.get_bool_opt({}, 'a', 'no'), False)
+        raises(util.OptionError, util.get_bool_opt, {}, 'a', [])
+        raises(util.OptionError, util.get_bool_opt, {}, 'a', 'foo')
+
+        equals(util.get_int_opt({}, 'a', 1), 1)
+        raises(util.OptionError, util.get_int_opt, {}, 'a', [])
+        raises(util.OptionError, util.get_int_opt, {}, 'a', 'bar')
+
+        equals(util.get_list_opt({}, 'a', [1]), [1])
+        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():
+            """
+            docstring headline
+
+            other text
+            """
+        def f2():
+            """
+            docstring
+            headline
+
+            other text
+            """
+
+        self.assertEqual(util.docstring_headline(f1), "docstring headline")
+        self.assertEqual(util.docstring_headline(f2), "docstring headline")
+
+    def test_analysator_returns_float(self):
+        # If an analysator wrapped by make_analysator returns a floating point
+        # number, then that number will be returned by the wrapper.
+        self.assertEqual(FakeLexer.analyse('0.5'), 0.5)
+
+    def test_analysator_returns_boolean(self):
+        # If an analysator wrapped by make_analysator returns a boolean value,
+        # then the wrapper will return 1.0 if the boolean was True or 0.0 if
+        # it was False.
+        self.assertEqual(FakeLexer.analyse(True), 1.0)
+        self.assertEqual(FakeLexer.analyse(False), 0.0)
+
+    def test_analysator_raises_exception(self):
+        # If an analysator wrapped by make_analysator raises an exception,
+        # then the wrapper will return 0.0.
+        class ErrorLexer(object):
+            def analyse(text):
+                raise RuntimeError('something bad happened')
+            analyse = util.make_analysator(analyse)
+        self.assertEqual(ErrorLexer.analyse(''), 0.0)
+
+    def test_analysator_value_error(self):
+        # When converting the analysator's return value to a float a
+        # ValueError may occur.  If that happens 0.0 is returned instead.
+        self.assertEqual(FakeLexer.analyse('bad input'), 0.0)
+
+    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)
+
+    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/python2.4', r'python(2\.\d)?'))
+        self.assertTrue(util.shebang_matches('#!/usr/bin/startsomethingwith python',
+                                             r'python(2\.\d)?'))
+        self.assertTrue(util.shebang_matches('#!C:\\Python2.4\\Python.exe',
+                                             r'python(2\.\d)?'))
+
+        self.assertFalse(util.shebang_matches('#!/usr/bin/python-ruby', r'python(2\.\d)?'))
+        self.assertFalse(util.shebang_matches('#!/usr/bin/python/ruby', r'python(2\.\d)?'))
+        self.assertFalse(util.shebang_matches('#!', r'python'))
+
+    def test_doctype_matches(self):
+        self.assertTrue(util.doctype_matches(
+            '<!DOCTYPE html PUBLIC "a"> <html>', 'html.*'))
+        self.assertFalse(util.doctype_matches(
+            '<?xml ?> <DOCTYPE html PUBLIC "a"> <html>', 'html.*'))
+        self.assertTrue(util.html_doctype_matches(
+            '<?xml ?><!DOCTYPE html PUBLIC  "-//W3C//DTD XHTML 1.0 Strict//EN">'))
+
+    def test_xml(self):
+        self.assertTrue(util.looks_like_xml(
+            '<?xml ?><!DOCTYPE html PUBLIC  "-//W3C//DTD XHTML 1.0 Strict//EN">'))
+        self.assertTrue(util.looks_like_xml('<html xmlns>abc</html>'))
+        self.assertFalse(util.looks_like_xml('<html>'))

data/vendor/simplejson/.gitignore

@@ -0,0 +1,10 @@
+*.egg-info
+*.egg
+*.pyc
+*.so
+/MANIFEST
+/.coverage
+/coverage.xml
+/build
+/dist
+/docs

data/vendor/simplejson/.travis.yml

@@ -0,0 +1,5 @@
+language: python
+python:
+  - "2.6"
+  - "2.7"
+script: python setup.py test

data/vendor/simplejson/CHANGES.txt

@@ -0,0 +1,291 @@
+Version 2.6.0 released 2012-06-26
+
+* Error messages changed to match proposal for Python 3.3.1
+  http://bugs.python.org/issue5067
+
+Version 2.5.2 released 2012-05-10
+
+* Fix for regression introduced in 2.5.1
+  https://github.com/simplejson/simplejson/issues/35
+
+Version 2.5.1 released 2012-05-10
+
+* Support for use_decimal=True in environments that use Python
+  sub-interpreters such as uWSGI
+  https://github.com/simplejson/simplejson/issues/34
+
+Version 2.5.0 released 2012-03-29
+
+* New item_sort_key option for encoder to allow fine grained control of sorted
+  output
+
+Version 2.4.0 released 2012-03-06
+
+* New bigint_as_string option for encoder to trade JavaScript number precision
+  issues for type issues.
+  https://github.com/simplejson/simplejson/issues/31
+
+Version 2.3.3 released 2012-02-27
+
+* Allow unknown numerical types for indent parameter
+  https://github.com/simplejson/simplejson/pull/29
+
+Version 2.3.2 released 2011-12-30
+
+* Fix crashing regression in speedups introduced in 2.3.1
+
+Version 2.3.1 released 2011-12-29
+
+* namedtuple_as_object now checks _asdict to ensure that it
+  is callable.
+  https://github.com/simplejson/simplejson/issues/26
+
+Version 2.3.0 released 2011-12-05
+
+* Any objects with _asdict() methods are now considered for
+  namedtuple_as_object.
+  https://github.com/simplejson/simplejson/pull/22
+
+Version 2.2.1 released 2011-09-06
+
+* Fix MANIFEST.in issue when building a sdist from a sdist.
+  https://github.com/simplejson/simplejson/issues/16
+
+Version 2.2.0 released 2011-09-04
+
+* Remove setuptools requirement, reverted to pure distutils
+* use_decimal default for encoding (dump, dumps, JSONEncoder) is now True
+* tuple encoding as JSON objects can be turned off with new
+  tuple_as_array=False option.
+  https://github.com/simplejson/simplejson/pull/6
+* namedtuple (or other tuple subclasses with _asdict methods) are now
+  encoded as JSON objects rather than arrays by default. Can be disabled
+  and treated as a tuple with the new namedtuple_as_object=False option.
+  https://github.com/simplejson/simplejson/pull/6
+* JSONDecodeError is now raised instead of ValueError when a document
+  ends with an opening quote and the C speedups are in use.
+  https://github.com/simplejson/simplejson/issues/15
+* Updated documentation with information about JSONDecodeError
+* Force unicode linebreak characters to be escaped (U+2028 and U+2029)
+  http://timelessrepo.com/json-isnt-a-javascript-subset
+* Moved documentation from a git submodule to
+  http://simplejson.readthedocs.org/
+
+Version 2.1.6 released 2011-05-08
+
+* Prevent segfaults with deeply nested JSON documents
+  https://github.com/simplejson/simplejson/issues/11
+* Fix compatibility with Python 2.5
+  https://github.com/simplejson/simplejson/issues/5
+
+Version 2.1.5 released 2011-04-17
+
+* Built sdist tarball with setuptools_git installed. Argh.
+
+Version 2.1.4 released 2011-04-17
+
+* Does not try to build the extension when using PyPy
+* Trailing whitespace after commas no longer emitted when indent is used
+* Migrated to github http://github.com/simplejson/simplejson
+
+Version 2.1.3 released 2011-01-17
+
+* Support the sort_keys option in C encoding speedups
+  http://code.google.com/p/simplejson/issues/detail?id=86
+* Allow use_decimal to work with dump()
+  http://code.google.com/p/simplejson/issues/detail?id=87
+
+Version 2.1.2 released 2010-11-01
+
+* Correct wrong end when object_pairs_hook is used
+  http://code.google.com/p/simplejson/issues/detail?id=85
+* Correct output for indent=0
+  http://bugs.python.org/issue10019
+* Correctly raise TypeError when non-string keys are used with speedups
+  http://code.google.com/p/simplejson/issues/detail?id=82
+* Fix the endlineno, endcolno attributes of the JSONDecodeError exception.
+  http://code.google.com/p/simplejson/issues/detail?id=81
+
+Version 2.1.1 released 2010-03-31
+
+* Change how setup.py imports ez_setup.py to try and workaround old versions
+  of setuptools.
+  http://code.google.com/p/simplejson/issues/detail?id=75
+* Fix compilation on Windows platform (and other platforms with very
+  picky compilers)
+* Corrected simplejson.__version__ and other minor doc changes.
+* Do not fail speedups tests if speedups could not be built.
+  http://code.google.com/p/simplejson/issues/detail?id=73
+
+Version 2.1.0 released 2010-03-10
+
+* Decimal serialization officially supported for encoding with
+  use_decimal=True. For encoding this encodes Decimal objects and
+  for decoding it implies parse_float=Decimal
+* Python 2.4 no longer supported (may still work, but no longer tested)
+* Decoding performance and memory utilization enhancements
+  http://bugs.python.org/issue7451
+* JSONEncoderForHTML class for escaping &, <, >
+  http://code.google.com/p/simplejson/issues/detail?id=66
+* Memoization of object keys during encoding (when using speedups)
+* Encoder changed to use PyIter_Next for list iteration to avoid
+  potential threading issues
+* Encoder changed to use iteritems rather than PyDict_Next in order to
+  support dict subclasses that have a well defined ordering
+  http://bugs.python.org/issue6105
+* indent encoding parameter changed to be a string rather than an integer
+  (integer use still supported for backwards compatibility)
+  http://code.google.com/p/simplejson/issues/detail?id=56
+* Test suite (python setup.py test) now automatically runs with and without
+  speedups
+  http://code.google.com/p/simplejson/issues/detail?id=55
+* Fixed support for older versions of easy_install (e.g. stock Mac OS X config)
+  http://code.google.com/p/simplejson/issues/detail?id=54
+* Fixed str/unicode mismatches when using ensure_ascii=False
+  http://code.google.com/p/simplejson/issues/detail?id=48
+* Fixed error message when parsing an array with trailing comma with speedups
+  http://code.google.com/p/simplejson/issues/detail?id=46
+* Refactor decoder errors to raise JSONDecodeError instead of ValueError
+  http://code.google.com/p/simplejson/issues/detail?id=45
+* New ordered_pairs_hook feature in decoder which makes it possible to
+  preserve key order. http://bugs.python.org/issue5381
+* Fixed containerless unicode float decoding (same bug as 2.0.4, oops!)
+  http://code.google.com/p/simplejson/issues/detail?id=43
+* Share PosInf definition between encoder and decoder
+* Minor reformatting to make it easier to backport simplejson changes
+  to Python 2.7/3.1 json module
+
+Version 2.0.9 released 2009-02-18
+
+* Adds cyclic GC to the Encoder and Scanner speedups, which could've
+  caused uncollectible cycles in some cases when using custom parser
+  or encoder functions
+
+Version 2.0.8 released 2009-02-15
+
+* Documentation fixes
+* Fixes encoding True and False as keys
+* Fixes checking for True and False by identity for several parameters
+
+Version 2.0.7 released 2009-01-04
+
+* Documentation fixes
+* C extension now always returns unicode strings when the input string is
+  unicode, even for empty strings
+
+Version 2.0.6 released 2008-12-19
+
+* Windows build fixes
+
+Version 2.0.5 released 2008-11-23
+
+* Fixes a segfault in the C extension when using check_circular=False and
+  encoding an invalid document
+
+Version 2.0.4 released 2008-10-24
+
+* Fixes a parsing error in the C extension when the JSON document is (only)
+  a floating point number. It would consume one too few characters in that
+  case, and claim the document invalid.
+
+Version 2.0.3 released 2008-10-11
+
+* Fixes reference leaks in the encoding speedups (sorry about that!)
+* Fixes doctest suite for Python 2.6
+* More optimizations for the decoder
+
+Version 2.0.2 released 2008-10-06
+
+* Fixes MSVC2003 build regression
+* Fixes Python 2.4 compatibility in _speedups.c
+
+Version 2.0.1 released 2008-09-29
+
+* Fixes long encoding regression introduced in 2.0.0
+* Fixes MinGW build regression introduced in 2.0.0
+
+Version 2.0.0 released 2008-09-27
+
+* optimized Python encoding path
+* optimized Python decoding path
+* optimized C encoding path
+* optimized C decoding path
+* switched to sphinx docs (nearly the same as the json module in python 2.6)
+
+Version 1.9.3 released 2008-09-23
+
+* Decoding is significantly faster (for our internal benchmarks)
+* Pretty-printing tool changed from simplejson to simplejson.tool for better
+  Python 2.6 comaptibility
+* Misc. bug fixes
+
+Version 1.9 released 2008-05-03
+
+* Rewrote test suite with unittest and doctest (no more nosetest dependency)
+* Better PEP 7 and PEP 8 source compliance
+* Removed simplejson.jsonfilter demo module
+* simplejson.jsonfilter is no longer included
+
+Version 1.8.1 released 2008-03-24
+
+* Optional C extension for accelerating the decoding of JSON strings
+* Command line interface for pretty-printing JSON (via python -msimplejson)
+* Decoding of integers and floats is now extensible (e.g. to use Decimal) via
+  parse_int, parse_float options.
+* Subversion and issue tracker moved to google code:
+  http://code.google.com/p/simplejson/
+* "/" is no longer escaped, so if you're embedding JSON directly in HTML
+  you'll want to use .replace("/", "\\/") to prevent a close-tag attack.
+
+Version 1.7 released 2007-03-18
+
+* Improves encoding performance with an optional C extension to speed up
+  str/unicode encoding (by 10-150x or so), which yields an overall speed
+  boost of 2x+ (JSON is string-heavy).
+* Support for encoding unicode code points outside the BMP to UTF-16
+  surrogate code pairs (specified by the Strings section of RFC 4627).
+
+Version 1.6 released 2007-03-03
+
+* Improved str support for encoding. Previous versions of simplejson
+  integrated strings directly into the output stream, this version ensures
+  they're of a particular encoding (default is UTF-8) so that the output
+  stream is valid.
+
+Version 1.5 released 2007-01-18
+
+* Better Python 2.5 compatibility
+* Better Windows compatibility
+* indent encoding parameter for pretty printing
+* separators encoding parameter for generating optimally compact JSON
+
+Version 1.3 released 2006-04-01
+
+* The optional object_hook function is called upon decoding of any JSON
+  object literal, and its return value is used instead of the dict that
+  would normally be used. This can be used to efficiently implement
+  features such as JSON-RPC class hinting, or other custom decodings of
+  JSON. See the documentation for more information.
+
+Version 1.1 released 2005-12-31
+
+* Renamed from simple_json to simplejson to comply with PEP 8 module naming
+  guidelines
+* Full set of documentation
+* More tests
+* The encoder and decoder have been extended to understand NaN, Infinity, and
+  -Infinity (but this can be turned off via allow_nan=False for strict JSON
+  compliance)
+* The decoder's scanner has been fixed so that it no longer accepts invalid
+  JSON documents
+* The decoder now reports line and column information as well as character
+  numbers for easier debugging
+* The encoder now has a circular reference checker, which can be optionally
+  disabled with check_circular=False
+* dump, dumps, load, loads now accept an optional cls kwarg to use an
+  alternate JSONEncoder or JSONDecoder class for convenience.
+* The read/write compatibility shim for json-py now have deprecation warnings
+
+Version 1.0 released 2005-12-25
+
+ * Initial release