dotum 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 58b55404177eb830e45206bf1ea8f436832f8101
+  data.tar.gz: 64901256ed0f3cd0ba95c6778d366a9f77502f40
+SHA512:
+  metadata.gz: 77e1a6e498214d1894a1b0c4bebd85e38a5fd4fe90a1dc44d7926871f3524c1a15778bd42e1f03ee16d175d582db513768357cc73631180b86b2008e447bcbe2
+  data.tar.gz: 7da1852a32c139a9921b8189d6cd61743bb65861e0a6faa927f7cba31cffd44a720797b838f64895b7f0f72354f52a97193b8b611cec61deff811e4a6e56b917

data/.gitignore

@@ -0,0 +1,5 @@
+coverage/
+doc/
+pkg/
+tmp/
+Gemfile.lock

data/.groc.json

@@ -0,0 +1,6 @@
+{
+  "glob": ["lib/**/*.rb", "README.md"],
+  "strip": ["lib/", "lib/dotum/"],
+  "github": true,
+  "whitespace-after-token": false
+}

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--format documentation
+--order random
+--require spec_helper

data/.simplecov

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+SimpleCov.start do
+  add_filter "/spec/"
+end

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+bundler_args: --without debugging guard
+script: bundle exec rake spec:ci
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - rbx-18mode
+  - rbx-19mode
+  - rbx-20mode
+  - jruby-18mode
+  - jruby-19mode
+  - jruby-20mode
+  - ree

data/CONTRIBUTING.md

@@ -0,0 +1,63 @@
+Hacking on Dotum
+=================
+
+Hopefully, Dotum's development environment is relatively straightfoward, but
+here's a walkthrough of its different facets.
+
+
+General Workflow
+----------------
+
+After checking out Dotum and installing its bundle, you should simply run
+`bundle exec guard` in a separate terminal window (or process).
+
+The general philosophy is that [Guard](https://github.com/guard/guard) should be
+managing the majority of the development workflow.  Any change you make should
+run the appropriate tests.
+
+
+Mutation-Driven Testing
+-----------------------
+
+Dotum strictly adheres to [mutation tests](tasks/spec/mutate.rake) for all core
+classes (not rules) via [mutant](https://github.com/mbj/mutant).  This may be a
+bit more stringent than you are used to, but it provides the following benefits:
+
+* **Complete coverage.**  Mutant will mutate just about every facet of every
+  function.
+
+* **Confidence.**  If the specs pass mutation testing, you can be reasonably
+  assured that a pull requests behaves as advertised.
+
+* **Redundancy avoidance.**  Mutation tests tend to highlight redundant and
+  useless code that can be safely removed.
+
+* **Enforced granularity.**  You tend to write smaller and more focused tests.
+
+Mutation tests do not run via `guard` (they take a while).  You should
+periodically run them via `rake` or `rake spec:mutate`.  You can also emulate
+the Travis environment via `rake spec:ci`.
+
+Additionally, you can run mutation specs against specific objects and/or methods
+by specifying them directly:
+
+* `rake spec:mutate[Foo]` would run mutation specs for methods defined on
+  `Dotum::Foo`.
+
+* `rake spec:mutate[Foo#bar]` would run mutation specs for the instance method
+  `bar` defined on `Dotum::Foo`.
+
+* `rake spec:mutate[Fizz.buzz]` would run mutation specs for the module method
+  `buzz` defined on `Dotum::Fizz`.
+
+
+Test Organization
+-----------------
+
+Both to support mutant, and for better visibility, tests are organized
+_per-method_.  For example:
+
+* `Foo::Bar#baz` should have tests located at `spec/unit/foo/bar/baz_spec.rb`.
+
+* `Fizz.buzz` should have tests located at
+  `spec/unit/class_methods/buzz_spec.rb`.

data/Gemfile

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+source "https://rubygems.org"
+
+gemspec
+
+# No gem would be complete without rake tasks - http://rake.rubyforge.org/
+gem "rake", "~> 10.1"
+
+group :test do
+  # Our preferred unit testing library - https://www.relishapp.com/rspec
+  gem "rspec", "~> 2.13"
+
+  # The preferred code mutation library.
+  gem "mutant", "~> 0.3.rc", :platforms => [:ruby_19, :ruby_20]
+
+  # Cover all the things - https://github.com/colszowka/simplecov
+  gem "simplecov", "~> 0.7"
+
+  # Code coverage in badge form - https://coveralls.io/
+  gem "coveralls", "~> 0.6"
+end
+
+group :debugging do
+  # A REPL like IRB, but much better - http://pryrepl.org/
+  gem "pry", "~> 0.9"
+
+  # Don't leave home without a debugger!
+  gem "debugger", "~> 1.6", :platforms => :mri
+end
+
+group :guard do
+  # A generic file system event handler; spin it up and see the tests fly
+  gem "guard", "~> 1.8"
+
+  # Guard configuration to manage our spork drb environments
+  gem "guard-spork", "~> 1.5"
+
+  # Guard configuration & hooks for rspec
+  gem "guard-rspec", "~> 3.0"
+
+  # File system event hooks for OS X
+  gem "rb-fsevent", "~> 0.9"
+
+  # File system event hooks for Linux
+  gem "rb-inotify", "~> 0.9"
+
+  # File system event hooks for Windows
+  gem "rb-fchange", "~> 0.0"
+
+  # OS X 10.8+ notification center support
+  gem "terminal-notifier-guard", "~> 1.5"
+
+  # libnotify bindings (Linux)
+  gem "libnotify", "~> 0.8"
+
+  # notifu adapter (Windows)
+  gem "rb-notifu", "~> 0.0"
+end

data/Guardfile

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+guard "spork", rspec_port: 2772 do
+  watch("Gemfile")
+  watch("Gemfile.lock")
+
+  # Touching any of these files should cause the entire test suite to reload.
+  SPEC_ENVIRONMENT_FILES = [
+    ".rspec",
+    %r{^spec/.*_helper\.rb$},
+    %r{^spec/common/.*\.rb$},
+  ]
+
+  SPEC_ENVIRONMENT_FILES.each do |pattern|
+    watch(pattern) { :rspec }
+  end
+end
+
+def specs_for_path(path)
+  ["spec/unit/#{path}_spec.rb", Dir["spec/unit/#{path}/**/*_spec.rb"]].flatten
+end
+
+guard "rspec", cli: "--drb --drb-port 2772" do
+  watch("lib/dotum.rb") { "spec" }
+  watch("lib/dotum/autoload_convention.rb") { "spec" }
+  watch(%r{^spec/fixtures/.*\.rb$}) { "spec" }
+
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}) { |m| specs_for_path(m[1]) }
+end

data/MIT-LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+=====================
+Copyright (c) 2013 Ian MacLeod <ian@nevir.net>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,24 @@
+Dotum
+=====
+
+[![Gem Version](https://badge.fury.io/rb/dotum.png)](https://rubygems.org/gems/dotum)
+[![Build Status](https://secure.travis-ci.org/nevir/dotum.png?branch=master)](http://travis-ci.org/nevir/dotum)
+[![Coverage Status](https://coveralls.io/repos/nevir/dotum/badge.png?branch=master)](https://coveralls.io/r/nevir/dotum)
+[![Code Climate](https://codeclimate.com/github/nevir/dotum.png)](https://codeclimate.com/github/nevir/dotum)
+
+Dotum manages your dotfiles and allows for piecemeal sharing.
+
+TODO.
+
+
+License
+-------
+
+Dotum is MIT licensed.  [See the accompanying file](MIT-LICENSE.md) for the
+full text.
+
+Dotum [also includes](extern/json/CHANGES.md) the pure-Ruby portions of
+[flori's JSON implementation](https://github.com/flori/json), which is
+[Ruby licensed](extern/json/COPYING).  This is used for Ruby implementations
+that do not already bundle it (i.e. 1.8), so that Dotum doesn't have to depend
+on other gems.

data/Rakefile

@@ -0,0 +1,15 @@
+#!/usr/bin/env rake
+# encoding: utf-8
+
+require "bundler/gem_tasks"
+
+PROJECT_ROOT = File.expand_path("..", __FILE__)
+Dir["#{PROJECT_ROOT}/tasks/**/*.rake"].each do |path|
+  load path
+end
+
+$LOAD_PATH.unshift File.join(PROJECT_ROOT, "lib")
+
+
+desc "Run the full test suite"
+task :default => [:spec, :"spec:mutate"]

data/bin/dotum

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+require "dotum"
+
+Dotum::CLI.exec(ARGV)

data/data/default_rules.dotum

@@ -0,0 +1,44 @@
+# Default `use` Behavior
+# ======================
+
+
+# Package Loading
+# --------------
+# Any directories that contain a `rules.dotum` are `use`d.
+package_paths = package_dir.relative_glob("**/rules.dotum")
+package_paths.map! { |p| File.dirname(p) }
+
+if package_paths.size > 1
+  package_paths.sort!
+
+  # but only the outermost packages.
+  #
+  # Parent packages get to dictate how their children are loaded.
+  filtered_paths = []
+  prev_path = nil
+  package_paths.each_with_index do |path, i|
+    next if prev_path && path.start_with?(prev_path)
+
+    prev_path = path
+    filtered_paths.push(path)
+  end
+
+  package_paths = filtered_paths
+end
+
+package_paths.each do |package_path|
+  use package_path
+end
+
+
+# Linking
+# -------
+# We link everything that doesn't fall under a package path.
+file_paths = package_dir.relative_glob("**/*", &:file?)
+file_paths.reject! { |file_path|
+  package_paths.any? { |package_path| file_path.start_with? package_path }
+}
+
+file_paths.each do |file_path|
+  link file_path
+end

data/dotum.gemspec

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require File.expand_path("../lib/dotum/version", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        =  "dotum"
+  gem.summary     =  "Dotum manages your dotfiles and allows for piecemeal sharing."
+  gem.authors     = ["Ian MacLeod"]
+  gem.email       = ["ian@nevir.net"]
+  gem.homepage    =  "https://github.com/nevir/dotum"
+
+  gem.version  = Dotum::VERSION
+  gem.platform = Gem::Platform::RUBY
+
+  gem.files      = `git ls-files`.split("\n")
+  gem.test_files = `git ls-files -- {spec}/*`.split("\n")
+
+  gem.require_paths = ["lib"]
+end

data/extern/json/CHANGES.md

@@ -0,0 +1,9 @@
+Changes for Dotum
+=================
+
+This JSON library was found at https://github.com/flori/json.
+
+There are _no_ code changes, but it has been stripped down to just the pure Ruby
+implementation.
+
+Dotum only uses this if a native JSON library is not available (aka 1.8).

data/extern/json/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/extern/json/README.rdoc

@@ -0,0 +1,358 @@
+= JSON implementation for Ruby {<img src="https://secure.travis-ci.org/flori/json.png" />}[http://travis-ci.org/flori/json]
+
+== 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
+
+The above command will build the extensions and install them on your system.
+
+  # rake install_pure
+
+or
+
+  # ruby install.rb
+
+will just install the pure ruby implementation of JSON.
+
+If you use Rubygems you can type
+
+  # 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
+
+== Compiling the extensions yourself
+
+If you want to build the extensions yourself you need rake:
+
+  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 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
+
+
+== Usage
+
+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'
+
+Now you can parse a JSON document into a ruby data structure by calling
+
+  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