cvss-suite 1.0.0

data/vendor/cache/ruby/2.2.0/gems/json-1.8.3/Gemfile

@@ -0,0 +1,10 @@
+# vim: set ft=ruby:
+
+source 'https://rubygems.org'
+
+gemspec :name => 'json'
+gemspec :name => 'json_pure'
+gemspec :name => 'json-java'
+
+gem 'utils'
+gem 'test-unit'

data/vendor/cache/ruby/2.2.0/gems/json-1.8.3/README-json-jruby.markdown

@@ -0,0 +1,33 @@
+JSON-JRuby
+==========
+
+JSON-JRuby is a port of Florian Frank's native
+[`json` library](http://json.rubyforge.org/) to JRuby.
+It aims to be a perfect drop-in replacement for `json_pure`.
+
+
+Development version
+===================
+
+The latest version is available from the
+[Git repository](http://github.com/mernen/json-jruby/tree):
+
+    git clone git://github.com/mernen/json-jruby.git
+
+
+Compiling
+=========
+
+You'll need JRuby version 1.2 or greater to build JSON-JRuby.
+Its path must be set on the `jruby.dir` property of
+`nbproject/project.properties` (defaults to `../jruby`).
+
+Additionally, you'll need [Ant](http://ant.apache.org/), and
+[Ragel](http://www.cs.queensu.ca/~thurston/ragel/) 6.4 or greater.
+
+Then, from the folder where the sources are located, type:
+
+    ant clean jar
+
+to clean any leftovers from previous builds and generate the `.jar` files.
+To generate a RubyGem, specify the `gem` action rather than `jar`.

data/vendor/cache/ruby/2.2.0/gems/json-1.8.3/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 native extension variant, which is in parts
+  implemented in C or Java 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

data/vendor/cache/ruby/2.2.0/gems/json-1.8.3/Rakefile

@@ -0,0 +1,412 @@
+begin
+  require 'rubygems/package_task'
+rescue LoadError
+end
+
+require 'rbconfig'
+include\
+  begin
+    RbConfig
+  rescue NameError
+    Config
+  end
+
+require 'rake/clean'
+CLOBBER.include 'doc', 'Gemfile.lock'
+CLEAN.include FileList['diagrams/*.*'], 'doc', 'coverage', 'tmp',
+  FileList["ext/**/{Makefile,mkmf.log}"], 'build', 'dist', FileList['**/*.rbc'],
+  FileList["{ext,lib}/**/*.{so,bundle,#{CONFIG['DLEXT']},o,obj,pdb,lib,manifest,exp,def,jar,class,dSYM}"],
+  FileList['java/src/**/*.class']
+
+require 'rake/testtask'
+class UndocumentedTestTask < Rake::TestTask
+  def desc(*) end
+end
+
+def skip_sdoc(src)
+  src.gsub(/^.*sdoc.*/) { |s| s + ' if RUBY_VERSION > "1.8.6"' }
+end
+
+MAKE   = ENV['MAKE']   || %w[gmake make].find { |c| system(c, '-v') }
+BUNDLE = ENV['BUNDLE'] || %w[bundle].find { |c| system(c, '-v') }
+PKG_NAME          = 'json'
+PKG_TITLE         = 'JSON Implementation for Ruby'
+PKG_VERSION       = File.read('VERSION').chomp
+PKG_FILES         = FileList[`git ls-files`.split(/\n/)]
+
+EXT_ROOT_DIR      = 'ext/json/ext'
+EXT_PARSER_DIR    = "#{EXT_ROOT_DIR}/parser"
+EXT_PARSER_DL     = "#{EXT_PARSER_DIR}/parser.#{CONFIG['DLEXT']}"
+RAGEL_PATH        = "#{EXT_PARSER_DIR}/parser.rl"
+EXT_PARSER_SRC    = "#{EXT_PARSER_DIR}/parser.c"
+EXT_GENERATOR_DIR = "#{EXT_ROOT_DIR}/generator"
+EXT_GENERATOR_DL  = "#{EXT_GENERATOR_DIR}/generator.#{CONFIG['DLEXT']}"
+EXT_GENERATOR_SRC = "#{EXT_GENERATOR_DIR}/generator.c"
+
+JAVA_DIR            = "java/src/json/ext"
+JAVA_RAGEL_PATH     = "#{JAVA_DIR}/Parser.rl"
+JAVA_PARSER_SRC     = "#{JAVA_DIR}/Parser.java"
+JAVA_SOURCES        = FileList["#{JAVA_DIR}/*.java"]
+JAVA_CLASSES        = []
+JRUBY_PARSER_JAR    = File.expand_path("lib/json/ext/parser.jar")
+JRUBY_GENERATOR_JAR = File.expand_path("lib/json/ext/generator.jar")
+
+RAGEL_CODEGEN     = %w[rlcodegen rlgen-cd ragel].find { |c| system(c, '-v') }
+RAGEL_DOTGEN      = %w[rlgen-dot rlgen-cd ragel].find { |c| system(c, '-v') }
+
+desc "Installing library (pure)"
+task :install_pure => :version do
+  ruby 'install.rb'
+end
+
+task :install_ext_really do
+  sitearchdir = CONFIG["sitearchdir"]
+  cd 'ext' do
+    for file in Dir["json/ext/*.#{CONFIG['DLEXT']}"]
+      d = File.join(sitearchdir, file)
+      mkdir_p File.dirname(d)
+      install(file, d)
+    end
+    warn " *** Installed EXT ruby library."
+  end
+end
+
+desc "Installing library (extension)"
+task :install_ext => [ :compile, :install_pure, :install_ext_really ]
+
+desc "Installing library (extension)"
+task :install => :install_ext
+
+if defined?(Gem) and defined?(Gem::PackageTask)
+  spec_pure = Gem::Specification.new do |s|
+    s.name = 'json_pure'
+    s.version = PKG_VERSION
+    s.summary = PKG_TITLE
+    s.description = "This is a JSON implementation in pure Ruby."
+
+    s.files = PKG_FILES
+
+    s.require_path = 'lib'
+    s.add_development_dependency 'permutation'
+    s.add_development_dependency 'sdoc', '~>0.3.16'
+    s.add_development_dependency 'rake', '~>0.9.2'
+
+    s.extra_rdoc_files << 'README.rdoc'
+    s.rdoc_options <<
+      '--title' <<  'JSON implemention for ruby' << '--main' << 'README.rdoc'
+    s.test_files.concat Dir['./tests/test_*.rb']
+
+    s.author = "Florian Frank"
+    s.email = "flori@ping.de"
+    s.homepage = "http://flori.github.com/#{PKG_NAME}"
+    s.license = 'Ruby'
+  end
+
+  desc 'Creates a json_pure.gemspec file'
+  task :gemspec_pure => :version do
+    File.open('json_pure.gemspec', 'w') do |gemspec|
+      gemspec.write skip_sdoc(spec_pure.to_ruby)
+    end
+  end
+
+  Gem::PackageTask.new(spec_pure) do |pkg|
+      pkg.need_tar = true
+      pkg.package_files = PKG_FILES
+  end
+
+  spec_ext = Gem::Specification.new do |s|
+    s.name = 'json'
+    s.version = PKG_VERSION
+    s.summary = PKG_TITLE
+    s.description = "This is a JSON implementation as a Ruby extension in C."
+
+    s.files = PKG_FILES
+
+    s.extensions = FileList['ext/**/extconf.rb']
+
+    s.require_path = 'lib'
+    s.add_development_dependency 'permutation'
+    s.add_development_dependency 'sdoc', '~>0.3.16'
+
+    s.extra_rdoc_files << 'README.rdoc'
+    s.rdoc_options <<
+      '--title' <<  'JSON implemention for Ruby' << '--main' << 'README.rdoc'
+    s.test_files.concat Dir['./tests/test_*.rb']
+
+    s.author = "Florian Frank"
+    s.email = "flori@ping.de"
+    s.homepage = "http://flori.github.com/#{PKG_NAME}"
+    s.license = 'Ruby'
+  end
+
+  desc 'Creates a json.gemspec file'
+  task :gemspec_ext => :version do
+    File.open('json.gemspec', 'w') do |gemspec|
+      gemspec.write skip_sdoc(spec_ext.to_ruby)
+    end
+  end
+
+  Gem::PackageTask.new(spec_ext) do |pkg|
+    pkg.need_tar      = true
+    pkg.package_files = PKG_FILES
+  end
+
+
+  desc 'Create all gemspec files'
+  task :gemspec => [ :gemspec_pure, :gemspec_ext ]
+end
+
+desc m = "Writing version information for #{PKG_VERSION}"
+task :version do
+  puts m
+  File.open(File.join('lib', 'json', 'version.rb'), 'w') do |v|
+    v.puts <<EOT
+module JSON
+  # JSON version
+  VERSION         = '#{PKG_VERSION}'
+  VERSION_ARRAY   = VERSION.split(/\\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end
+EOT
+  end
+end
+
+desc "Testing library (pure ruby)"
+task :test_pure => [ :clean, :do_test_pure ]
+
+UndocumentedTestTask.new do |t|
+  t.name = 'do_test_pure'
+  t.libs << 'lib'
+  t.test_files = FileList['tests/test_*.rb']
+  t.verbose = true
+  t.options = '-v'
+end
+
+desc "Testing library (pure ruby and extension)"
+task :test do
+  sh "env JSON=pure #{BUNDLE} exec rake test_pure" or exit 1
+  sh "env JSON=ext #{BUNDLE} exec rake test_ext"  or exit 1
+end
+
+namespace :gems do
+  desc 'Install all development gems'
+  task :install do
+    sh "#{BUNDLE}"
+  end
+end
+
+if defined?(RUBY_ENGINE) and RUBY_ENGINE == 'jruby'
+  if ENV.key?('JAVA_HOME')
+    warn " *** JAVA_HOME was set to #{ENV['JAVA_HOME'].inspect}"
+  elsif File.directory?(local_java = '/usr/local/java/jdk') ||
+    File.directory?(local_java = '/usr/lib/jvm/java-6-openjdk')
+  then
+    ENV['JAVA_HOME'] = local_java
+  end
+  if ENV['JAVA_HOME']
+    warn " *** JAVA_HOME is set to #{ENV['JAVA_HOME'].inspect}"
+    ENV['PATH'] = ENV['PATH'].split(/:/).unshift(java_path = "#{ENV['JAVA_HOME']}/bin") * ':'
+    warn " *** java binaries are assumed to be in #{java_path.inspect}"
+  else
+    warn " *** JAVA_HOME was not set or could not be guessed!"
+    exit 1
+  end
+
+  file JAVA_PARSER_SRC => JAVA_RAGEL_PATH do
+    cd JAVA_DIR do
+      if RAGEL_CODEGEN == 'ragel'
+        sh "ragel Parser.rl -J -o Parser.java"
+      else
+        sh "ragel -x Parser.rl | #{RAGEL_CODEGEN} -J"
+      end
+    end
+  end
+
+  desc "Generate parser for java with ragel"
+  task :ragel => JAVA_PARSER_SRC
+
+  desc "Delete the ragel generated Java source"
+  task :ragel_clean do
+    rm_rf JAVA_PARSER_SRC
+  end
+
+  JRUBY_JAR = File.join(CONFIG["libdir"], "jruby.jar")
+  if File.exist?(JRUBY_JAR)
+    JAVA_SOURCES.each do |src|
+      classpath = (Dir['java/lib/*.jar'] << 'java/src' << JRUBY_JAR) * ':'
+      obj = src.sub(/\.java\Z/, '.class')
+      file obj => src do
+        sh 'javac', '-classpath', classpath, '-source', '1.5', '-target', '1.5', src
+      end
+      JAVA_CLASSES << obj
+    end
+  else
+    warn "WARNING: Cannot find jruby in path => Cannot build jruby extension!"
+  end
+
+  desc "Compiling jruby extension"
+  task :compile => JAVA_CLASSES
+
+  desc "Package the jruby gem"
+  task :jruby_gem => :create_jar do
+    sh 'gem build json-java.gemspec'
+    mkdir_p 'pkg'
+    mv "json-#{PKG_VERSION}-java.gem", 'pkg'
+  end
+
+  desc "Testing library (jruby)"
+  task :test_ext => [ :create_jar, :do_test_ext ]
+
+  UndocumentedTestTask.new do |t|
+    t.name = 'do_test_ext'
+    t.libs << 'lib'
+    t.test_files = FileList['tests/test_*.rb']
+    t.verbose = true
+    t.options = '-v'
+  end
+
+  file JRUBY_PARSER_JAR => :compile do
+    cd 'java/src' do
+      parser_classes = FileList[
+        "json/ext/ByteListTranscoder*.class",
+        "json/ext/OptionsReader*.class",
+        "json/ext/Parser*.class",
+        "json/ext/RuntimeInfo*.class",
+        "json/ext/StringDecoder*.class",
+        "json/ext/Utils*.class"
+      ]
+      sh 'jar', 'cf', File.basename(JRUBY_PARSER_JAR), *parser_classes
+      mv File.basename(JRUBY_PARSER_JAR), File.dirname(JRUBY_PARSER_JAR)
+    end
+  end
+
+  desc "Create parser jar"
+  task :create_parser_jar => JRUBY_PARSER_JAR
+
+  file JRUBY_GENERATOR_JAR => :compile do
+    cd 'java/src' do
+      generator_classes = FileList[
+        "json/ext/ByteListTranscoder*.class",
+        "json/ext/OptionsReader*.class",
+        "json/ext/Generator*.class",
+        "json/ext/RuntimeInfo*.class",
+        "json/ext/StringEncoder*.class",
+        "json/ext/Utils*.class"
+      ]
+      sh 'jar', 'cf', File.basename(JRUBY_GENERATOR_JAR), *generator_classes
+      mv File.basename(JRUBY_GENERATOR_JAR), File.dirname(JRUBY_GENERATOR_JAR)
+    end
+  end
+
+  desc "Create generator jar"
+  task :create_generator_jar => JRUBY_GENERATOR_JAR
+
+  desc "Create parser and generator jars"
+  task :create_jar => [ :create_parser_jar, :create_generator_jar ]
+
+  desc "Build all gems and archives for a new release of the jruby extension."
+  task :build => [ :clean, :version, :jruby_gem ]
+
+  task :release => :build
+else
+  desc "Compiling extension"
+  task :compile => [ EXT_PARSER_DL, EXT_GENERATOR_DL ]
+
+  file EXT_PARSER_DL => EXT_PARSER_SRC do
+    cd EXT_PARSER_DIR do
+      ruby 'extconf.rb'
+      sh MAKE
+    end
+    cp "#{EXT_PARSER_DIR}/parser.#{CONFIG['DLEXT']}", EXT_ROOT_DIR
+  end
+
+  file EXT_GENERATOR_DL => EXT_GENERATOR_SRC do
+    cd EXT_GENERATOR_DIR do
+      ruby 'extconf.rb'
+      sh MAKE
+    end
+    cp "#{EXT_GENERATOR_DIR}/generator.#{CONFIG['DLEXT']}", EXT_ROOT_DIR
+  end
+
+  desc "Testing library (extension)"
+  task :test_ext => [ :compile, :do_test_ext ]
+
+  UndocumentedTestTask.new do |t|
+    t.name = 'do_test_ext'
+    t.libs << 'ext' << 'lib'
+    t.test_files = FileList['tests/test_*.rb']
+    t.verbose = true
+    t.options = '-v'
+  end
+
+  desc "Create RDOC documentation"
+  task :doc => [ :version, EXT_PARSER_SRC ] do
+    sh "sdoc -o doc -t '#{PKG_TITLE}' -m README.rdoc README.rdoc lib/json.rb #{FileList['lib/json/**/*.rb']} #{EXT_PARSER_SRC} #{EXT_GENERATOR_SRC}"
+  end
+
+  desc "Generate parser with ragel"
+  task :ragel => EXT_PARSER_SRC
+
+  desc "Delete the ragel generated C source"
+  task :ragel_clean do
+    rm_rf EXT_PARSER_SRC
+  end
+
+  desc "Update the tags file"
+  task :tags do
+    system 'ctags', *Dir['**/*.{rb,c,h,java}']
+  end
+
+  file EXT_PARSER_SRC => RAGEL_PATH do
+    cd EXT_PARSER_DIR do
+      if RAGEL_CODEGEN == 'ragel'
+        sh "ragel parser.rl -G2 -o parser.c"
+      else
+        sh "ragel -x parser.rl | #{RAGEL_CODEGEN} -G2"
+      end
+      src = File.read("parser.c").gsub(/[ \t]+$/, '')
+      File.open("parser.c", "w") {|f| f.print src}
+    end
+  end
+
+  desc "Generate diagrams of ragel parser (ps)"
+  task :ragel_dot_ps do
+    root = 'diagrams'
+    specs = []
+    File.new(RAGEL_PATH).grep(/^\s*machine\s*(\S+);\s*$/) { specs << $1 }
+    for s in specs
+      if RAGEL_DOTGEN == 'ragel'
+        sh "ragel #{RAGEL_PATH} -S#{s} -p -V | dot -Tps -o#{root}/#{s}.ps"
+      else
+        sh "ragel -x #{RAGEL_PATH} -S#{s} | #{RAGEL_DOTGEN} -p|dot -Tps -o#{root}/#{s}.ps"
+      end
+    end
+  end
+
+  desc "Generate diagrams of ragel parser (png)"
+  task :ragel_dot_png do
+    root = 'diagrams'
+    specs = []
+    File.new(RAGEL_PATH).grep(/^\s*machine\s*(\S+);\s*$/) { specs << $1 }
+    for s in specs
+      if RAGEL_DOTGEN == 'ragel'
+        sh "ragel #{RAGEL_PATH} -S#{s} -p -V | dot -Tpng -o#{root}/#{s}.png"
+      else
+        sh "ragel -x #{RAGEL_PATH} -S#{s} | #{RAGEL_DOTGEN} -p|dot -Tpng -o#{root}/#{s}.png"
+      end
+    end
+  end
+
+  desc "Generate diagrams of ragel parser"
+  task :ragel_dot => [ :ragel_dot_png, :ragel_dot_ps ]
+
+  desc "Build all gems and archives for a new release of json and json_pure."
+  task :build => [ :clean, :gemspec, :package ]
+
+  task :release => :build
+end
+
+desc "Compile in the the source directory"
+task :default => [ :clean, :gemspec, :test ]