json_pure 1.0.0 → 1.4.6

data/CHANGES

@@ -1,3 +1,157 @@
+2010-08-09 (1.4.6)
+  * Fixed oversight reported in http://github.com/flori/json/issues/closed#issue/23,
+    always create a new object from the state prototype.
+  * Made pure and ext api more similar again.
+2010-08-07 (1.4.5)
+  * Manage data structure nesting depth in state object during generation. This
+    should reduce problems with to_json method definіtions that only have one
+    argument.
+  * Some fixes in the state objects and additional tests.
+2010-08-06 (1.4.4)
+  * Fixes build problem for rubinius under OS X, http://github.com/flori/json/issues/closed#issue/25
+  * Fixes crashes described in http://github.com/flori/json/issues/closed#issue/21 and
+    http://github.com/flori/json/issues/closed#issue/23
+2010-05-05 (1.4.3)
+  * Fixed some test assertions, from Ruby r27587 and r27590, patch by nobu.
+  * Fixed issue http://github.com/flori/json/issues/#issue/20 reported by
+    electronicwhisper@github. Thx!
+2010-04-26 (1.4.2)
+  * Applied patch from naruse Yui NARUSE <naruse@airemix.com> to make building with
+    Microsoft Visual C possible again.
+  * Applied patch from devrandom <c1.github@niftybox.net> in order to allow building of
+    json_pure if extensiontask is not present.
+  * Thanks to Dustin Schneider <dustin@stocktwits.com>, who reported a memory
+    leak, which is fixed in this release.
+  * Applied 993f261ccb8f911d2ae57e9db48ec7acd0187283 patch from josh@github.
+2010-04-25 (1.4.1)
+  * Fix for a bug reported by Dan DeLeo <dan@kallistec.com>, caused by T_FIXNUM
+    being different on 32bit/64bit architectures.
+2010-04-23 (1.4.0)
+  * Major speed improvements and building with simplified
+    directory/file-structure.
+  * Extension should at least be comapatible with MRI, YARV and Rubinius.
+2010-04-07 (1.2.4)
+  * Triger const_missing callback to make Rails' dynamic class loading work.
+2010-03-11 (1.2.3)
+  * Added a State#[] method which returns an attribute's value in order to
+    increase duck type compatibility to Hash.
+2010-02-27 (1.2.2)
+  * Made some changes to make the building of the parser/generator compatible
+    to Rubinius.
+2009-11-25 (1.2.1)
+  * Added :symbolize_names option to Parser, which returns symbols instead of
+    strings in object names/keys.
+2009-10-01 (1.2.0)
+  * fast_generate now raises an exeception for nan and infinite floats.
+  * On Ruby 1.8 json supports parsing of UTF-8, UTF-16BE, UTF-16LE, UTF-32BE,
+    and UTF-32LE JSON documents now. Under Ruby 1.9 the M17n conversion
+    functions are used to convert from all supported encodings. ASCII-8BIT
+    encoded strings are handled like all strings under Ruby 1.8 were.
+  * Better documentation
+2009-08-23 (1.1.9)
+  * Added forgotten main doc file extra_rdoc_files.
+2009-08-23 (1.1.8)
+  * Applied a patch by OZAWA Sakuro <sakuro@2238club.org> to make json/pure
+    work in environments that don't provide iconv.
+  * Applied patch by okkez_ in order to fix Ruby Bug #1768:
+      http://redmine.ruby-lang.org/issues/show/1768.
+  * Finally got around to avoid the rather paranoid escaping of ?/ characters
+    in the generator's output. The parsers aren't affected by this change.
+    Thanks to Rich Apodaca <rapodaca@metamolecular.com> for the suggestion.
+2009-06-29 (1.1.7)
+  * Security Fix for JSON::Pure::Parser. A specially designed string could
+    cause catastrophic backtracking in one of the parser's regular expressions
+    in earlier 1.1.x versions. JSON::Ext::Parser isn't affected by this issue.
+    Thanks to Bartosz Blimke <bartosz@new-bamboo.co.uk> for reporting this
+    problem.
+  * This release also uses a less strict ruby version requirement for the
+    creation of the mswin32 native gem.
+2009-05-10 (1.1.6)
+  * No changes. І tested native linux gems in the last release and they don't
+    play well with different ruby versions other than the one the gem was built
+    with. This release is just to bump the version number in order to skip the
+    native gem on rubyforge.
+2009-05-10 (1.1.5)
+  * Started to build gems with rake-compiler gem.
+  * Applied patch object/array class patch from Brian Candler
+    <B.Candler@pobox.com> and fixes.
+2009-04-01 (1.1.4)
+  * Fixed a bug in the creation of serialized generic rails objects reported by
+    Friedrich Graeter <graeter@hydrixos.org>.
+  * Deleted tests/runner.rb, we're using testrb instead.
+  * Editor supports Infinity in numbers now.
+  * Made some changes in order to get the library to compile/run under Ruby
+    1.9.
+  * Improved speed of the code path for the fast_generate method in the pure
+    variant.
+2008-07-10 (1.1.3)
+  * Wesley Beary <monki@geemus.com> reported a bug in json/add/core's DateTime
+    handling: If the nominator and denominator of the offset were divisible by
+    each other Ruby's Rational#to_s returns them as an integer not a fraction
+    with '/'. This caused a ZeroDivisionError during parsing.
+  * Use Date#start and DateTime#start instead of sg method, while
+    remaining backwards compatible.
+  * Supports ragel >= 6.0 now.
+  * Corrected some tests.
+  * Some minor changes.
+2007-11-27 (1.1.2)
+  * Remember default dir (last used directory) in editor.
+  * JSON::Editor.edit method added, the editor can now receive json texts from
+    the clipboard via C-v.
+  * Load json texts from an URL pasted via middle button press.
+  * Added :create_additions option to Parser. This makes it possible to disable
+    the creation of additions by force, in order to treat json texts as data
+    while having additions loaded.
+  * Jacob Maine <jmaine@blurb.com> reported, that JSON(:foo) outputs a JSON
+    object if the rails addition is enabled, which is wrong. It now outputs a
+    JSON string "foo" instead, like suggested by Jacob Maine.
+  * Discovered a bug in the Ruby Bugs Tracker on rubyforge, that was reported
+    by John Evans lgastako@gmail.com. He could produce a crash in the JSON
+    generator by returning something other than a String instance from a
+    to_json method. I now guard against this by doing a rather crude type
+    check, which raises an exception instead of crashing.
+2007-07-06 (1.1.1)
+  * Yui NARUSE <naruse@airemix.com> sent some patches to fix tests for Ruby
+    1.9. I applied them and adapted some of them a bit to run both on 1.8 and
+    1.9.
+  * Introduced a JSON.parse! method without depth checking for people who like
+    danger.
+  * Made generate and pretty_generate methods configurable by an options hash.
+  * Added :allow_nan option to parser and generator in order to handle NaN,
+    Infinity, and -Infinity correctly - if requested. Floats, which aren't numbers,
+    aren't valid JSON according to RFC4627, so by default an exception will be
+    raised if any of these symbols are encountered. Thanks to Andrea Censi
+    <andrea.censi@dis.uniroma1.it> for his hint about this.
+  * Fixed some more tests for Ruby 1.9.
+  * Implemented dump/load interface of Marshal as suggested in ruby-core:11405
+    by murphy <murphy@rubychan.de>.
+  * Implemented the max_nesting feature for generate methods, too.
+  * Added some implementations for ruby core's custom objects for
+    serialisation/deserialisation purposes.
+2007-05-21 (1.1.0)
+  * Implemented max_nesting feature for parser to avoid stack overflows for
+    data from untrusted sources. If you trust the source, you can disable it
+    with the option max_nesting => false.
+  * Piers Cawley <pdcawley@bofh.org.uk> reported a bug, that not every
+    character can be escaped by ?\ as required by RFC4627. There's a
+    contradiction between David Crockford's JSON checker test vectors (in
+    tests/fixtures) and RFC4627, though. I decided to stick to the RFC, because
+    the JSON checker seems to be a bit older than the RFC.
+  * Extended license to Ruby License, which includes the GPL.
+  * Added keyboard shortcuts, and 'Open location' menu item to edit_json.rb.
+2007-05-09 (1.0.4)
+  * Applied a patch from Yui NARUSE <naruse@airemix.com> to make JSON compile
+    under Ruby 1.9. Thank you very much for mailing it to me!
+  * Made binary variants of JSON fail early, instead of falling back to the
+    pure version. This should avoid overshadowing of eventual problems while
+    loading of the binary.
+2007-03-24 (1.0.3)
+  * Improved performance of pure variant a bit.
+  * The ext variant of this release supports the mswin32 platform. Ugh!
+2007-03-24 (1.0.2)
+  * Ext Parser didn't parse 0e0 correctly into 0.0: Fixed!
+2007-03-24 (1.0.1)
+  * Forgot some object files in the build dir. I really like that - not!
 2007-03-24 (1.0.0)
   * Added C implementations for the JSON generator and a ragel based JSON
     parser in C.
@@ -12,7 +166,7 @@
     well.
   * Added aliases generate and pretty_generate of unparse and pretty_unparse.
   * Fixed a test case.
-  * Catch an Іconv::InvalidEncoding exception, that seems to occur on some Sun
+  * Catch an Iconv::InvalidEncoding exception, that seems to occur on some Sun
     boxes with SunOS 5.8, if iconv doesn't support utf16 conversions. This was
     reported by Andrew R Jackson <andrewj@bcm.tmc.edu>, thanks a bunch!
 2006-08-25 (0.4.2)

data/COPYING

@@ -0,0 +1,58 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.co.jp>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see GPL file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+     files under the ./missing directory.  See each file for the copying
+     condition.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.
+

data/GPL

@@ -1,12 +1,12 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
 
  Copyright (C) 1989, 1991 Free Software Foundation, Inc.
                        59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
-			    Preamble
+                            Preamble
 
   The licenses for most software are designed to take away your
 freedom to share and change it.  By contrast, the GNU General Public
@@ -56,7 +56,7 @@ patent must be licensed for everyone's free use or not licensed at all.
   The precise terms and conditions for copying, distribution and
 modification follow.
 
-		    GNU GENERAL PUBLIC LICENSE
+                    GNU GENERAL PUBLIC LICENSE
    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
   0. This License applies to any program or other work which contains
@@ -255,7 +255,7 @@ make exceptions for this.  Our decision will be guided by the two goals
 of preserving the free status of all derivatives of our free software and
 of promoting the sharing and reuse of software generally.
 
-			    NO WARRANTY
+                            NO WARRANTY
 
   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
@@ -277,9 +277,9 @@ YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 
-		     END OF TERMS AND CONDITIONS
+                     END OF TERMS AND CONDITIONS
 
-	    How to Apply These Terms to Your New Programs
+            How to Apply These Terms to Your New Programs
 
   If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it

data/README

@@ -1,77 +1,356 @@
-Dependencies for Building
-=========================
-
-- You need rake to build the extensions and install them.
-
-  You can get it from rubyforge:
-    http://rubyforge.org/projects/rake
-
-  or just type
-
-  # gem install rake
-
-  for the installation via rubygems.
-
-- If you want to rebuild the parser.c file or draw nice graphviz images of the
-  state machines, you need ragel from:
-    http://www.cs.queensu.ca/~thurston/ragel
-
-Installation
-============
-
-It's recommended to use the extension variant of JSON, because it's quite a bit
-faster than the pure ruby variant. If you cannot build it on your system, you
-can settle for the latter.
+== Description
+
+This is a implementation of the JSON specification according to RFC 4627
+http://www.ietf.org/rfc/rfc4627.txt . Starting from version 1.0.0 on there
+will be two variants available:
+
+* A pure ruby variant, that relies on the iconv and the stringscan
+  extensions, which are both part of the ruby standard library.
+* The quite a bit faster C extension variant, which is in parts implemented
+  in C and comes with its own unicode conversion functions and a parser
+  generated by the ragel state machine compiler
+  http://www.cs.queensu.ca/~thurston/ragel .
+
+Both variants of the JSON generator generate UTF-8 character sequences by
+default. If an :ascii_only option with a true value is given, they escape all
+non-ASCII and control characters with \uXXXX escape sequences, and support
+UTF-16 surrogate pairs in order to be able to generate the whole range of
+unicode code points.
+
+All strings, that are to be encoded as JSON strings, should be UTF-8 byte
+sequences on the Ruby side. To encode raw binary strings, that aren't UTF-8
+encoded, please use the to_json_raw_object method of String (which produces
+an object, that contains a byte array) and decode the result on the receiving
+endpoint.
+
+The JSON parsers can parse UTF-8, UTF-16BE, UTF-16LE, UTF-32BE, and UTF-32LE
+JSON documents under Ruby 1.8. Under Ruby 1.9 they take advantage of Ruby's
+M17n features and can parse all documents which have the correct
+String#encoding set. If a document string has ASCII-8BIT as an encoding the
+parser attempts to figure out which of the UTF encodings from above it is and
+trys to parse it.
+
+== Installation
+
+It's recommended to use the extension variant of JSON, because it's faster than
+the pure ruby variant. If you cannot build it on your system, you can settle
+for the latter.
 
 Just type into the command line as root:
 
-# rake install
+  # rake install
 
 The above command will build the extensions and install them on your system.
 
-# rake install_pure
+  # rake install_pure
 
 or
 
-# ruby install.rb
+  # ruby install.rb
 
 will just install the pure ruby implementation of JSON.
 
 If you use Rubygems you can type
 
-# gem install json
+  # gem install json
 
 instead, to install the newest JSON version.
 
 There is also a pure ruby json only variant of the gem, that can be installed
 with:
 
-# gem install json_pure
+  # gem install json_pure
 
-Testing and Examples
-====================
+== Compiling the extensions yourself
 
-To run the tests type:
+If you want to build the extensions yourself you need rake:
 
-$ rake test_ext
+  You can get it from rubyforge:
+    http://rubyforge.org/projects/rake
 
-This will build the extensions first and then test them.
+  or just type
 
-$ rake test_pure
+  # gem install rake
 
-This will test the pure ruby extensions.
+  for the installation via rubygems.
+
+If you want to create the parser.c file from its parser.rl file or draw nice
+graphviz images of the state machines, you need ragel from: http://www.cs.queensu.ca/~thurston/ragel
 
-There is also a small example in tools/server.rb if you want to see, how
-receiving a JSON object from a webrick server in your browser with the
-javasript prototype library (http://www.prototypejs.org) works.
 
-Author
-======
+== Usage
 
-Florian Frank <flori@ping.de>
+To use JSON you can
+  require 'json'
+to load the installed variant (either the extension 'json' or the pure
+variant 'json_pure'). If you have installed the extension variant, you can
+pick either the extension variant or the pure variant by typing
+  require 'json/ext'
+or
+  require 'json/pure'
 
-License
-=======
+Now you can parse a JSON document into a ruby data structure by calling
 
-GNU General Public License (GPL), Version 2
+  JSON.parse(document)
 
+If you want to generate a JSON document from a ruby data structure call
+  JSON.generate(data)
+
+You can also use the pretty_generate method (which formats the output more
+verbosely and nicely) or fast_generate (which doesn't do any of the security
+checks generate performs, e. g. nesting deepness checks).
+
+To create a valid JSON document you have to make sure, that the output is
+embedded in either a JSON array [] or a JSON object {}. The easiest way to do
+this, is by putting your values in a Ruby Array or Hash instance.
+
+There are also the JSON and JSON[] methods which use parse on a String or
+generate a JSON document from an array or hash:
+
+  document = JSON 'test'  => 23 # => "{\"test\":23}"
+  document = JSON['test'] => 23 # => "{\"test\":23}"
+
+and
+
+  data = JSON '{"test":23}'  # => {"test"=>23}
+  data = JSON['{"test":23}'] # => {"test"=>23}
+
+You can choose to load a set of common additions to ruby core's objects if
+you
+  require 'json/add/core'
+
+After requiring this you can, e. g., serialise/deserialise Ruby ranges:
+
+  JSON JSON(1..10) # => 1..10
+
+To find out how to add JSON support to other or your own classes, read the
+section "More Examples" below.
+
+To get the best compatibility to rails' JSON implementation, you can
+  require 'json/add/rails'
+
+Both of the additions attempt to require 'json' (like above) first, if it has
+not been required yet.
+
+== More Examples
+
+To create a JSON document from a ruby data structure, you can call
+JSON.generate like that:
+
+ json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+ # => "[1,2,{\"a\":3.141},false,true,null,\"4..10\"]"
+
+To get back a ruby data structure from a JSON document, you have to call
+JSON.parse on it:
+
+ JSON.parse json
+ # => [1, 2, {"a"=>3.141}, false, true, nil, "4..10"]
+
+Note, that the range from the original data structure is a simple
+string now. The reason for this is, that JSON doesn't support ranges
+or arbitrary classes. In this case the json library falls back to call
+Object#to_json, which is the same as #to_s.to_json.
+
+It's possible to add JSON support serialization to arbitrary classes by
+simply implementing a more specialized version of the #to_json method, that
+should return a JSON object (a hash converted to JSON with #to_json) like
+this (don't forget the *a for all the arguments):
+
+ class Range
+   def to_json(*a)
+     {
+       'json_class'   => self.class.name, # = 'Range'
+       'data'         => [ first, last, exclude_end? ]
+     }.to_json(*a)
+   end
+ end
+
+The hash key 'json_class' is the class, that will be asked to deserialise the
+JSON representation later. In this case it's 'Range', but any namespace of
+the form 'A::B' or '::A::B' will do. All other keys are arbitrary and can be
+used to store the necessary data to configure the object to be deserialised.
+
+If a the key 'json_class' is found in a JSON object, the JSON parser checks
+if the given class responds to the json_create class method. If so, it is
+called with the JSON object converted to a Ruby hash. So a range can
+be deserialised by implementing Range.json_create like this:
+
+ class Range
+   def self.json_create(o)
+     new(*o['data'])
+   end
+ end
+
+Now it possible to serialise/deserialise ranges as well:
+
+ json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+ # => "[1,2,{\"a\":3.141},false,true,null,{\"json_class\":\"Range\",\"data\":[4,10,false]}]"
+ JSON.parse json
+ # => [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
+
+JSON.generate always creates the shortest possible string representation of a
+ruby data structure in one line. This is good for data storage or network
+protocols, but not so good for humans to read. Fortunately there's also
+JSON.pretty_generate (or JSON.pretty_generate) that creates a more readable
+output:
+
+ puts JSON.pretty_generate([1, 2, {"a"=>3.141}, false, true, nil, 4..10])
+ [
+   1,
+   2,
+   {
+     "a": 3.141
+   },
+   false,
+   true,
+   null,
+   {
+     "json_class": "Range",
+     "data": [
+       4,
+       10,
+       false
+     ]
+   }
+ ]
+
+There are also the methods Kernel#j for generate, and Kernel#jj for
+pretty_generate output to the console, that work analogous to Core Ruby's p and
+the pp library's pp methods.
+
+The script tools/server.rb contains a small example if you want to test, how
+receiving a JSON object from a webrick server in your browser with the
+javasript prototype library http://www.prototypejs.org works.
+
+== Speed Comparisons
+
+I have created some benchmark results (see the benchmarks/data-p4-3Ghz
+subdir of the package) for the JSON-parser to estimate the speed up in the C
+extension:
+
+ Comparing times (call_time_mean):
+  1 ParserBenchmarkExt#parser   900 repeats:
+        553.922304770 (  real) ->   21.500x 
+          0.001805307
+  2 ParserBenchmarkYAML#parser  1000 repeats:
+        224.513358139 (  real) ->    8.714x 
+          0.004454078
+  3 ParserBenchmarkPure#parser  1000 repeats:
+         26.755020642 (  real) ->    1.038x 
+          0.037376163
+  4 ParserBenchmarkRails#parser 1000 repeats:
+         25.763381731 (  real) ->    1.000x 
+          0.038814780
+            calls/sec (  time) ->    speed  covers
+            secs/call
+
+In the table above 1 is JSON::Ext::Parser, 2 is YAML.load with YAML
+compatbile JSON document, 3 is is JSON::Pure::Parser, and 4 is
+ActiveSupport::JSON.decode. The ActiveSupport JSON-decoder converts the
+input first to YAML and then uses the YAML-parser, the conversion seems to
+slow it down so much that it is only as fast as the JSON::Pure::Parser!
+
+If you look at the benchmark data you can see that this is mostly caused by
+the frequent high outliers - the median of the Rails-parser runs is still
+overall smaller than the median of the JSON::Pure::Parser runs:
+
+ Comparing times (call_time_median):
+  1 ParserBenchmarkExt#parser   900 repeats:
+        800.592479481 (  real) ->   26.936x 
+          0.001249075
+  2 ParserBenchmarkYAML#parser  1000 repeats:
+        271.002390644 (  real) ->    9.118x 
+          0.003690004
+  3 ParserBenchmarkRails#parser 1000 repeats:
+         30.227910865 (  real) ->    1.017x 
+          0.033082008
+  4 ParserBenchmarkPure#parser  1000 repeats:
+         29.722384421 (  real) ->    1.000x 
+          0.033644676
+            calls/sec (  time) ->    speed  covers
+            secs/call
+
+I have benchmarked the JSON-Generator as well. This generated a few more
+values, because there are different modes that also influence the achieved
+speed:
+
+ Comparing times (call_time_mean):
+  1 GeneratorBenchmarkExt#generator_fast    1000 repeats:
+        547.354332608 (  real) ->   15.090x 
+          0.001826970
+  2 GeneratorBenchmarkExt#generator_safe    1000 repeats:
+        443.968212317 (  real) ->   12.240x 
+          0.002252414
+  3 GeneratorBenchmarkExt#generator_pretty  900 repeats:
+        375.104545883 (  real) ->   10.341x 
+          0.002665923
+  4 GeneratorBenchmarkPure#generator_fast   1000 repeats:
+         49.978706968 (  real) ->    1.378x 
+          0.020008521
+  5 GeneratorBenchmarkRails#generator       1000 repeats:
+         38.531868759 (  real) ->    1.062x 
+          0.025952543
+  6 GeneratorBenchmarkPure#generator_safe   1000 repeats:
+         36.927649925 (  real) ->    1.018x 7 (>=3859)
+          0.027079979
+  7 GeneratorBenchmarkPure#generator_pretty 1000 repeats:
+         36.272134441 (  real) ->    1.000x 6 (>=3859)
+          0.027569373
+            calls/sec (  time) ->    speed  covers
+            secs/call
+
+In the table above 1-3 are JSON::Ext::Generator methods. 4, 6, and 7 are
+JSON::Pure::Generator methods and 5 is the Rails JSON generator. It is now a
+bit faster than the generator_safe and generator_pretty methods of the pure
+variant but slower than the others.
+
+To achieve the fastest JSON document output, you can use the fast_generate
+method. Beware, that this will disable the checking for circular Ruby data
+structures, which may cause JSON to go into an infinite loop.
+
+Here are the median comparisons for completeness' sake:
+
+ Comparing times (call_time_median):
+  1 GeneratorBenchmarkExt#generator_fast    1000 repeats:
+        708.258020939 (  real) ->   16.547x 
+          0.001411915
+  2 GeneratorBenchmarkExt#generator_safe    1000 repeats:
+        569.105020353 (  real) ->   13.296x 
+          0.001757145
+  3 GeneratorBenchmarkExt#generator_pretty  900 repeats:
+        482.825371244 (  real) ->   11.280x 
+          0.002071142
+  4 GeneratorBenchmarkPure#generator_fast   1000 repeats:
+         62.717626652 (  real) ->    1.465x 
+          0.015944481
+  5 GeneratorBenchmarkRails#generator       1000 repeats:
+         43.965681162 (  real) ->    1.027x 
+          0.022745013
+  6 GeneratorBenchmarkPure#generator_safe   1000 repeats:
+         43.929073409 (  real) ->    1.026x 7 (>=3859)
+          0.022763968
+  7 GeneratorBenchmarkPure#generator_pretty 1000 repeats:
+         42.802514491 (  real) ->    1.000x 6 (>=3859)
+          0.023363113
+            calls/sec (  time) ->    speed  covers
+            secs/call
+
+== Author
+
+Florian Frank <mailto:flori@ping.de>
+
+== License
+
+Ruby License, see the COPYING file included in the source distribution. The
+Ruby License includes the GNU General Public License (GPL), Version 2, so see
+the file GPL as well.
+
+== Download
+
+The latest version of this library can be downloaded at
+
+* http://rubyforge.org/frs?group_id=953
+
+Online Documentation should be located at
+
+* http://json.rubyforge.org