pygments.rb 0.2.13 → 0.3.0

data/test/test_pygments.rb

@@ -1,148 +1,272 @@
-# coding: utf-8
+#coding: utf-8
 
 require 'test/unit'
-require 'pygments'
+require File.join(File.dirname(__FILE__), '..', '/lib/pygments.rb')
+ENV['mentos-test'] = "yes"
 
-class PygmentsLexerTest < Test::Unit::TestCase
-  include Pygments
+P = Pygments
 
+class PygmentsHighlightTest < Test::Unit::TestCase
   RUBY_CODE = "#!/usr/bin/ruby\nputs 'foo'"
+  RUBY_CODE_TRAILING_NEWLINE = "#!/usr/bin/ruby\nputs 'foo'\n"
+  REDIS_CODE = File.read(File.join(File.dirname(__FILE__), '..', '/test/test_data.c'))
+
+  def test_highlight_defaults_to_html
+    code = P.highlight(RUBY_CODE)
+    assert_match '<span class="c1">#!/usr/bin/ruby</span>', code
+    assert_equal '<div class', code[0..9]
+  end
+
+  def test_highlight_works_with_larger_files
+    code = P.highlight(REDIS_CODE)
+    assert_match 'used_memory_peak_human', code
+    assert_equal 454107, code.bytesize.to_i
+  end
+
+  def test_returns_nil_on_timeout
+    large_code = REDIS_CODE * 300
+    code = P.highlight(large_code) # a 30 mb highlight request will timeout
+    assert_equal nil, code
+  end
+
+  def test_highlight_works_with_null_bytes
+    code = P.highlight("\0hello", :lexer => 'rb')
+    assert_match "hello", code
+  end
+
+  def test_highlight_works_on_utf8
+    code = P.highlight('# ø', :lexer => 'rb', :options => {:encoding => 'utf-8'})
+    assert_match "# ø", code
+  end
+
+  def test_highlight_works_on_utf8_automatically
+    code = P.highlight('# ø', :lexer => 'rb')
+    assert_match "# ø", code
+  end
+
+  def test_highlight_works_on_utf8_all_chars_automatically
+    code = P.highlight('def foo: # ø', :lexer => 'py')
+
+    assert_equal '<div class="highlight"><pre><span clas', code[0,38]
+  end
+
+  def test_highlight_works_with_multiple_utf8
+    code = P.highlight('# ø ø ø', :lexer => 'rb', :options => {:encoding => 'utf-8'})
+    assert_match "# ø ø ø", code
+  end
+
+  def test_highlight_works_with_multiple_utf8_and_trailing_newline
+    code = P.highlight("#!/usr/bin/ruby\nputs 'ø..ø'\n", :lexer => 'rb')
+    assert_match "ø..ø", code
+  end
+
+  def test_highlight_formatter_bbcode
+    code = P.highlight(RUBY_CODE, :formatter => 'bbcode')
+    assert_match 'color=#408080][i]#!/usr/bin/ruby[/i]', code
+  end
+
+  def test_highlight_formatter_terminal
+    code = P.highlight(RUBY_CODE, :formatter => 'terminal')
+    assert_match '39;49;00m', code
+  end
+
+  def test_highlight_options
+    code = P.highlight(RUBY_CODE, :options => {:full => true, :title => 'test'})
+    assert_match '<title>test</title>', code
+  end
+
+  def test_highlight_works_with_single_character_input
+    code = P.highlight("a")
+    assert_match 'a</span>', code
+  end
+
+  def test_highlight_works_with_trailing_newline
+    code = P.highlight(RUBY_CODE_TRAILING_NEWLINE)
+    assert_match '<span class="c1">#!/usr/bin/ruby</span>', code
+  end
+
+  def test_highlight_works_with_multiple_newlines
+    code = P.highlight(RUBY_CODE_TRAILING_NEWLINE + "derp\n\n")
+    assert_match '<span class="c1">#!/usr/bin/ruby</span>', code
+  end
+
+  def test_highlight_works_with_trailing_cr
+    code = P.highlight(RUBY_CODE_TRAILING_NEWLINE + "\r")
+    assert_match '<span class="c1">#!/usr/bin/ruby</span>', code
+  end
+
+  def test_highlight_still_works_with_invalid_code
+    code = P.highlight("importr python;    wat?", :lexer => 'py')
+    assert_match ">importr</span>", code
+  end
+end
+
+# Philosophically, I'm not the biggest fan of testing private
+# methods, but given the relative delicacy of validity checking
+# over the pipe I think it's necessary and informative.
+class PygmentsValidityTest < Test::Unit::TestCase
+  def test_add_ids_with_padding
+    res = P.send(:add_ids, "herp derp baz boo foo", "ABCDEFGH")
+    assert_equal "ABCDEFGH  herp derp baz boo foo  ABCDEFGH", res
+  end
+
+  def test_add_ids_on_empty_string
+    res = P.send(:add_ids, "", "ABCDEFGH")
+    assert_equal "ABCDEFGH    ABCDEFGH", res
+  end
+
+  def test_add_ids_with_unicode_data
+    res = P.send(:add_ids, "# ø ø ø", "ABCDEFGH")
+    assert_equal "ABCDEFGH  # ø ø ø  ABCDEFGH", res
+  end
+
+  def test_add_ids_with_starting_slashes
+    res = P.send(:add_ids, '\\# ø ø ø..//', "ABCDEFGH")
+    assert_equal "ABCDEFGH  \\# ø ø ø..//  ABCDEFGH", res
+  end
+
+  def test_get_fixed_bits_from_header
+    bits = P.send(:get_fixed_bits_from_header, '{"herp": "derp"}')
+    assert_equal "00000000000000000000000000010000", bits
+  end
+
+  def test_get_fixed_bits_from_header_works_with_large_headers
+    bits = P.send(:get_fixed_bits_from_header, '{"herp": "derp"}' * 10000)
+    assert_equal "00000000000000100111000100000000", bits
+  end
+
+  def test_size_check
+    size = "00000000000000000000000000100110"
+    res = P.send(:size_check, size)
+    assert_equal res, true
+  end
 
-  def test_lexer_by_content
-    assert_equal 'rb', lexer_name_for(RUBY_CODE)
+  def test_size_check_bad
+    size = "some random thing"
+    res = P.send(:size_check, size)
+    assert_equal res, false
   end
+end
+
+class PygmentsLexerTest < Test::Unit::TestCase
+  RUBY_CODE = "#!/usr/bin/ruby\nputs 'foo'"
+
   def test_lexer_by_mimetype
-    assert_equal 'rb', lexer_name_for(:mimetype => 'text/x-ruby')
+    assert_equal 'rb', P.lexer_name_for(:mimetype => 'text/x-ruby')
+    assert_equal 'json', P.lexer_name_for(:mimetype => 'application/json')
   end
+
   def test_lexer_by_filename
-    assert_equal 'rb', lexer_name_for(:filename => 'test.rb')
+    assert_equal 'rb', P.lexer_name_for(:filename => 'test.rb')
+    assert_equal 'scala', P.lexer_name_for(:filename => 'test.scala')
   end
+
   def test_lexer_by_name
-    assert_equal 'rb', lexer_name_for(:lexer => 'ruby')
+    assert_equal 'rb', P.lexer_name_for(:lexer => 'ruby')
+    assert_equal 'python', P.lexer_name_for(:lexer => 'python')
+    assert_equal 'c', P.lexer_name_for(:lexer => 'c')
   end
+
   def test_lexer_by_filename_and_content
-    assert_equal 'rb', lexer_name_for(RUBY_CODE, :filename => 'test.rb')
+    assert_equal 'rb', P.lexer_name_for(RUBY_CODE, :filename => 'test.rb')
   end
+
   def test_lexer_by_nothing
-    assert_equal nil, lexer_name_for(:invalid => true)
+    assert_raise MentosError do
+      P.lexer_name_for(:invalid => true)
+    end
   end
 end
 
 class PygmentsLexerClassTest < Test::Unit::TestCase
-  include Pygments
-
   def test_find
-    assert_equal 'Ruby', Lexer['Ruby'].name
-    assert_equal 'Ruby', Lexer['ruby'].name
-    assert_equal 'Ruby', Lexer['rb'].name
-    assert_equal 'Ruby', Lexer['rake'].name
-    assert_equal 'Ruby', Lexer['gemspec'].name
+    assert_equal 'Ruby', P::Lexer['Ruby'].name
+    assert_equal 'Ruby', P::Lexer['ruby'].name
+    assert_equal 'Ruby', P::Lexer['rb'].name
+    assert_equal 'Ruby', P::Lexer['rake'].name
+    assert_equal 'Ruby', P::Lexer['gemspec'].name
   end
+
   def test_find_by_name
-    assert_equal Lexer['Ruby'], Lexer.find_by_name('Ruby')
+    assert_equal P::Lexer['Ruby'], P::Lexer.find_by_name('Ruby')
+    assert_equal P::Lexer['C'], P::Lexer.find_by_name('C')
   end
+
   def test_find_by_alias
-    assert_equal Lexer['Ruby'], Lexer.find_by_alias('rb')
-    assert_equal Lexer['Ruby'], Lexer.find_by_alias('ruby')
+    assert_equal P::Lexer['Ruby'], P::Lexer.find_by_alias('rb')
+    assert_equal P::Lexer['Ruby'], P::Lexer.find_by_alias('ruby')
+    assert_equal P::Lexer['Scala'], P::Lexer.find_by_alias('scala')
+    assert_equal P::Lexer['Go'], P::Lexer.find_by_alias('go')
   end
+
   def test_find_lexer_by_extname
-    assert_equal Lexer['Ruby'], Lexer.find_by_extname('.rb')
-    assert_equal Lexer['PHP'], Lexer.find_by_extname('.php4')
-    assert_equal Lexer['PHP'], Lexer.find_by_extname('.php5')
-    assert_equal Lexer['Groff'], Lexer.find_by_extname('.1')
-    assert_equal Lexer['Groff'], Lexer.find_by_extname('.3')
+    assert_equal P::Lexer['Ruby'], P::Lexer.find_by_extname('.rb')
+    assert_equal P::Lexer['PHP'], P::Lexer.find_by_extname('.php4')
+    assert_equal P::Lexer['PHP'], P::Lexer.find_by_extname('.php5')
+    assert_equal P::Lexer['Groff'], P::Lexer.find_by_extname('.1')
+    assert_equal P::Lexer['Groff'], P::Lexer.find_by_extname('.3')
+    assert_equal P::Lexer['C'], P::Lexer.find_by_extname('.c')
+    assert_equal P::Lexer['C'], P::Lexer.find_by_extname('.h')
+    assert_equal P::Lexer['Python'], P::Lexer.find_by_extname('.py')
+    assert_equal P::Lexer['Java'], P::Lexer.find_by_extname('.java')
   end
-  def test_find_lexer_by_mimetype
-    assert_equal Lexer['Ruby'], Lexer.find_by_mimetype('text/x-ruby')
+
+ def test_find_lexer_by_mimetype
+    assert_equal P::Lexer['Ruby'], P::Lexer.find_by_mimetype('text/x-ruby')
+    assert_equal P::Lexer['JSON'], P::Lexer.find_by_mimetype('application/json')
+    assert_equal P::Lexer['Python'], P::Lexer.find_by_mimetype('text/x-python')
   end
 end
 
+
 class PygmentsCssTest < Test::Unit::TestCase
   include Pygments
 
   def test_css
-    assert_match /^\.err \{/, css
+    assert_match /^\.err \{/, P.css
   end
+
   def test_css_prefix
-    assert_match /^\.highlight \.err \{/, css('.highlight')
+    assert_match /^\.highlight \.err \{/, P.css('.highlight')
   end
+
   def test_css_options
-    assert_match /^\.codeerr \{/, css(:classprefix => 'code')
+    assert_match /^\.codeerr \{/, P.css(:classprefix => 'code')
   end
+
   def test_css_prefix_and_options
-    assert_match /^\.mycode \.codeerr \{/, css('.mycode', :classprefix => 'code')
+    assert_match /^\.mycode \.codeerr \{/, P.css('.mycode', :classprefix => 'code')
   end
+
   def test_css_default
-    assert_match '.c { color: #408080; font-style: italic }', css
+    assert_match '.c { color: #408080; font-style: italic }', P.css
   end
+
   def test_css_colorful
-    assert_match '.c { color: #808080 }', css(:style => 'colorful')
+    assert_match '.c { color: #888888 }', P.css(:style => 'colorful')
   end
 end
 
 class PygmentsConfigTest < Test::Unit::TestCase
-  include Pygments
-
   def test_styles
-    assert styles.include?('colorful')
+    assert P.styles.include?('colorful')
   end
+
   def test_filters
-    assert filters.include?('codetagify')
+    assert P.filters.include?('codetagify')
   end
+
   def test_lexers
-    list = lexers
+    list = P.lexers
     assert list.has_key?('Ruby')
     assert list['Ruby'][:aliases].include?('duby')
   end
+
   def test_formatters
-    list = formatters
+    list = P.formatters
     assert list.has_key?('Html')
     assert list['Html'][:aliases].include?('html')
   end
 end
 
-class PygmentsHighlightTest < Test::Unit::TestCase
-  include Pygments
-
-  RUBY_CODE = "#!/usr/bin/ruby\nputs 'foo'"
-
-  def test_highlight_empty
-    highlight('')
-    highlight(nil)
-  end
-
-  def test_highlight_defaults_to_html
-    code = highlight(RUBY_CODE)
-    assert_match '<span class="c1">#!/usr/bin/ruby</span>', code
-  end
-
-  def test_highlight_markdown_compatible_html
-    code = highlight(RUBY_CODE)
-    assert_no_match %r{</pre></div>\Z}, code
-  end
-
-  def test_highlight_works_with_null_bytes
-    code = highlight("\0hello", :lexer => 'rb')
-    assert_match "hello", code
-  end
-
-  def test_highlight_works_on_utf8
-    code = highlight('# ø', :lexer => 'rb', :options => {:encoding => 'utf-8'})
-    assert_match '<span class="c1"># ø</span>', code
-  end
-
-  def test_highlight_formatter_bbcode
-    code = highlight(RUBY_CODE, :formatter => 'bbcode')
-    assert_match '[i]#!/usr/bin/ruby[/i]', code
-  end
 
-  def test_highlight_formatter_terminal
-    code = highlight(RUBY_CODE, :formatter => 'terminal')
-    assert_match "\e[37m#!/usr/bin/ruby\e[39;49;00m", code
-  end
-
-  def test_highlight_options
-    code = highlight(RUBY_CODE, :options => {:full => true, :title => 'test'})
-    assert_match '<title>test</title>', code
-  end
-end

data/vendor/pygments-main/pygments/lexers/_mapping.py

@@ -35,7 +35,7 @@ LEXERS = {
     'AwkLexer': ('pygments.lexers.other', 'Awk', ('awk', 'gawk', 'mawk', 'nawk'), ('*.awk',), ('application/x-awk',)),
     'BBCodeLexer': ('pygments.lexers.text', 'BBCode', ('bbcode',), (), ('text/x-bbcode',)),
     'BaseMakefileLexer': ('pygments.lexers.text', 'Base Makefile', ('basemake',), (), ()),
-    'BashLexer': ('pygments.lexers.shell', 'Bash', ('bash', 'sh', 'ksh'), ('*.sh', '*.ksh', '*.bash', '*.ebuild', '*.eclass', '.bashrc', 'bashrc', '.bash_*', 'bash_*'), ('application/x-sh', 'application/x-shellscript')),
+    'BashLexer': ('pygments.lexers.shell', 'Bash', ('bash', 'sh', 'ksh', 'shell'), ('*.sh', '*.ksh', '*.bash', '*.ebuild', '*.eclass', '.bashrc', 'bashrc', '.bash_*', 'bash_*'), ('application/x-sh', 'application/x-shellscript')),
     'BashSessionLexer': ('pygments.lexers.shell', 'Bash Session', ('console',), ('*.sh-session',), ('application/x-shell-session',)),
     'BatchLexer': ('pygments.lexers.shell', 'Batchfile', ('bat',), ('*.bat', '*.cmd'), ('application/x-dos-batch',)),
     'BefungeLexer': ('pygments.lexers.other', 'Befunge', ('befunge',), ('*.befunge',), ('application/x-befunge',)),

data/vendor/pygments-main/pygments/lexers/shell.py

@@ -31,7 +31,7 @@ class BashLexer(RegexLexer):
     """
 
     name = 'Bash'
-    aliases = ['bash', 'sh', 'ksh']
+    aliases = ['bash', 'sh', 'ksh', 'shell']
     filenames = ['*.sh', '*.ksh', '*.bash', '*.ebuild', '*.eclass',
                  '.bashrc', 'bashrc', '.bash_*', 'bash_*']
     mimetypes = ['application/x-sh', 'application/x-shellscript']

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