yajl-ruby 1.0.0-x86-mswin32-60

data/lib/yajl/json_gem.rb

@@ -0,0 +1,15 @@
+puts "DEPRECATION WARNING: Yajl's JSON gem compatibility API is going to be removed in 2.0"
+
+require 'yajl' unless defined?(Yajl::Parser)
+require 'yajl/json_gem/parsing'
+require 'yajl/json_gem/encoding'
+
+module ::Kernel
+  def JSON(object, opts = {})
+    if object.respond_to? :to_s
+      JSON.parse(object.to_s, JSON.default_options.merge(opts))
+    else
+      JSON.generate(object, opts)
+    end
+  end
+end

data/lib/yajl/json_gem/encoding.rb

@@ -0,0 +1,51 @@
+require 'yajl' unless defined?(Yajl::Parser)
+
+# NOTE: this is probably temporary until I can split out the JSON compat C code into it's own
+# extension that can be included when this file is.
+Yajl::Encoder.enable_json_gem_compatability
+
+# Our fallback to_json definition
+unless defined?(ActiveSupport)
+  class Object
+    def to_json(*args, &block)
+      "\"#{to_s}\""
+    end
+  end
+end
+
+module JSON
+  class JSONError < StandardError; end unless defined?(JSON::JSONError)
+  class GeneratorError < JSONError; end unless defined?(JSON::GeneratorError)
+
+  def self.generate(obj, opts={})
+    begin
+      options_map = {}
+      if opts.has_key?(:indent)
+        options_map[:pretty] = true
+        options_map[:indent] = opts[:indent]
+      end
+      Yajl::Encoder.encode(obj, options_map)
+    rescue Yajl::EncodeError => e
+      raise JSON::GeneratorError, e.message
+    end
+  end
+
+  def self.pretty_generate(obj, opts={})
+    begin
+      options_map = {}
+      options_map[:pretty] = true
+      options_map[:indent] = opts[:indent] if opts.has_key?(:indent)
+      Yajl::Encoder.encode(obj, options_map)
+    rescue Yajl::EncodeError => e
+      raise JSON::GeneratorError, e.message
+    end
+  end
+
+  def self.dump(obj, io=nil, *args)
+    begin
+      Yajl::Encoder.encode(obj, io)
+    rescue Yajl::EncodeError => e
+      raise JSON::GeneratorError, e.message
+    end
+  end
+end

data/lib/yajl/json_gem/parsing.rb

@@ -0,0 +1,26 @@
+require 'yajl' unless defined?(Yajl::Parser)
+
+module JSON
+  class JSONError < StandardError; end unless defined?(JSON::JSONError)
+  class ParserError < JSONError; end unless defined?(JSON::ParserError)
+
+  def self.default_options
+    @default_options ||= {:symbolize_keys => false}
+  end
+
+  def self.parse(str, opts=JSON.default_options)
+    begin
+      Yajl::Parser.parse(str, opts)
+    rescue Yajl::ParseError => e
+      raise JSON::ParserError, e.message
+    end
+  end
+
+  def self.load(input, *args)
+    begin
+      Yajl::Parser.parse(input, default_options)
+    rescue Yajl::ParseError => e
+      raise JSON::ParserError, e.message
+    end
+  end
+end

data/lib/yajl/version.rb

@@ -0,0 +1,3 @@
+module Yajl
+  VERSION = '1.0.0'
+end

data/lib/yajl/yajl.rb

@@ -0,0 +1,2 @@
+RUBY_VERSION =~ /(\d+.\d+)/
+require "yajl/#{$1}/yajl"

data/spec/encoding/encoding_spec.rb

@@ -0,0 +1,271 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+class Dummy2
+  def to_json
+    "{\"hawtness\":true}"
+  end
+end
+
+class TheMindKiller
+  def to_json
+    @wait_i_dont_exist_this_is_a_horrible_mistake_dont_do_it_aiiiiiiiiieeeeeee
+  end
+end
+
+class TheMindKillerDuce
+  def to_s
+    @wait_i_dont_exist_this_is_a_horrible_mistake_dont_do_it_aiiiiiiiiieeeeeee
+  end
+end
+
+describe "Yajl JSON encoder" do
+  FILES = Dir[File.dirname(__FILE__)+'/../../benchmark/subjects/*.json']
+
+  FILES.each do |file|
+     it "should encode #{File.basename(file)} to an IO" do
+       # we don't care about testing the stream subject as it has multiple JSON strings in it
+       if File.basename(file) != 'twitter_stream.json'
+         input = File.new(File.expand_path(file), 'r')
+         io = StringIO.new
+         encoder = Yajl::Encoder.new
+         hash = Yajl::Parser.parse(input)
+         encoder.encode(hash, io)
+         io.rewind
+         hash2 = Yajl::Parser.parse(io)
+         io.close
+         input.close
+         hash.should == hash2
+       end
+     end
+   end
+
+   FILES.each do |file|
+     it "should encode #{File.basename(file)} and return a String" do
+       # we don't care about testing the stream subject as it has multiple JSON strings in it
+       if File.basename(file) != 'twitter_stream.json'
+         input = File.new(File.expand_path(file), 'r')
+         encoder = Yajl::Encoder.new
+         hash = Yajl::Parser.parse(input)
+         output = encoder.encode(hash)
+         hash2 = Yajl::Parser.parse(output)
+         input.close
+         hash.should == hash2
+       end
+     end
+   end
+
+   FILES.each do |file|
+     it "should encode #{File.basename(file)} call the passed block, passing it a String" do
+       # we don't care about testing the stream subject as it has multiple JSON strings in it
+       if File.basename(file) != 'twitter_stream.json'
+         input = File.new(File.expand_path(file), 'r')
+         encoder = Yajl::Encoder.new
+         hash = Yajl::Parser.parse(input)
+         output = ''
+         encoder.encode(hash) do |json_str|
+           output << json_str
+         end
+         hash2 = Yajl::Parser.parse(output)
+         input.close
+         hash.should == hash2
+       end
+     end
+   end
+
+  it "should encode with :pretty turned on and a single space indent, to an IO" do
+    output = "{\n \"foo\": 1234\n}"
+    obj = {:foo => 1234}
+    io = StringIO.new
+    encoder = Yajl::Encoder.new(:pretty => true, :indent => ' ')
+    encoder.encode(obj, io)
+    io.rewind
+    io.read.should == output
+  end
+
+  it "should encode with :pretty turned on and a single space indent, and return a String" do
+    output = "{\n \"foo\": 1234\n}"
+    obj = {:foo => 1234}
+    encoder = Yajl::Encoder.new(:pretty => true, :indent => ' ')
+    output = encoder.encode(obj)
+    output.should == output
+  end
+
+  it "should encode with :pretty turned on and a tab character indent, to an IO" do
+    output = "{\n\t\"foo\": 1234\n}"
+    obj = {:foo => 1234}
+    io = StringIO.new
+    encoder = Yajl::Encoder.new(:pretty => true, :indent => "\t")
+    encoder.encode(obj, io)
+    io.rewind
+    io.read.should == output
+  end
+
+  it "should encode with :pretty turned on and a tab character indent, and return a String" do
+    output = "{\n\t\"foo\": 1234\n}"
+    obj = {:foo => 1234}
+    encoder = Yajl::Encoder.new(:pretty => true, :indent => "\t")
+    output = encoder.encode(obj)
+    output.should == output
+  end
+
+  it "should encode with it's class method with :pretty and a tab character indent options set, to an IO" do
+    output = "{\n\t\"foo\": 1234\n}"
+    obj = {:foo => 1234}
+    io = StringIO.new
+    Yajl::Encoder.encode(obj, io, :pretty => true, :indent => "\t")
+    io.rewind
+    io.read.should == output
+  end
+
+  it "should encode with it's class method with :pretty and a tab character indent options set, and return a String" do
+    output = "{\n\t\"foo\": 1234\n}"
+    obj = {:foo => 1234}
+    output = Yajl::Encoder.encode(obj, :pretty => true, :indent => "\t")
+    output.should == output
+  end
+
+  it "should encode with it's class method with :pretty and a tab character indent options set, to a block" do
+    output = "{\n\t\"foo\": 1234\n}"
+    obj = {:foo => 1234}
+    output = ''
+    Yajl::Encoder.encode(obj, :pretty => true, :indent => "\t") do |json_str|
+      output = json_str
+    end
+    output.should == output
+  end
+
+  it "should encode multiple objects into a single stream, to an IO" do
+    io = StringIO.new
+    obj = {:foo => 1234}
+    encoder = Yajl::Encoder.new
+    5.times do
+      encoder.encode(obj, io)
+    end
+    io.rewind
+    output = "{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}"
+    io.read.should == output
+  end
+
+  it "should encode multiple objects into a single stream, and return a String" do
+    obj = {:foo => 1234}
+    encoder = Yajl::Encoder.new
+    json_output = ''
+    5.times do
+      json_output << encoder.encode(obj)
+    end
+    output = "{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}{\"foo\":1234}"
+    json_output.should == output
+  end
+
+  it "should encode all map keys as strings" do
+    Yajl::Encoder.encode({1=>1}).should eql("{\"1\":1}")
+  end
+
+  it "should check for and call #to_json if it exists on custom objects" do
+    d = Dummy2.new
+    Yajl::Encoder.encode({:foo => d}).should eql('{"foo":{"hawtness":true}}')
+  end
+
+  it "should encode a hash where the key and value can be symbols" do
+    Yajl::Encoder.encode({:foo => :bar}).should eql('{"foo":"bar"}')
+  end
+
+  it "should encode using a newline or nil terminator" do
+    Yajl::Encoder.new(:terminator => "\n").encode({:foo => :bar}).should eql("{\"foo\":\"bar\"}\n")
+    Yajl::Encoder.new(:terminator => nil).encode({:foo => :bar}).should eql("{\"foo\":\"bar\"}")
+  end
+
+  it "should encode using a newline or nil terminator, to an IO" do
+    s = StringIO.new
+    Yajl::Encoder.new(:terminator => "\n").encode({:foo => :bar}, s)
+    s.rewind
+    s.read.should eql("{\"foo\":\"bar\"}\n")
+
+    s = StringIO.new
+    Yajl::Encoder.new(:terminator => nil).encode({:foo => :bar}, s)
+    s.rewind
+    s.read.should eql("{\"foo\":\"bar\"}")
+  end
+
+  it "should encode using a newline or nil terminator, using a block" do
+    s = StringIO.new
+    Yajl::Encoder.new(:terminator => "\n").encode({:foo => :bar}) do |chunk|
+      s << chunk
+    end
+    s.rewind
+    s.read.should eql("{\"foo\":\"bar\"}\n")
+
+    s = StringIO.new
+    nilpassed = false
+    Yajl::Encoder.new(:terminator => nil).encode({:foo => :bar}) do |chunk|
+      nilpassed = true if chunk.nil?
+      s << chunk
+    end
+    nilpassed.should be_true
+    s.rewind
+    s.read.should eql("{\"foo\":\"bar\"}")
+  end
+
+  it "should not encode NaN" do
+    lambda {
+      Yajl::Encoder.encode(0.0/0.0)
+    }.should raise_error(Yajl::EncodeError)
+  end
+
+  it "should not encode Infinity or -Infinity" do
+    lambda {
+      Yajl::Encoder.encode(1.0/0.0)
+    }.should raise_error(Yajl::EncodeError)
+    lambda {
+      Yajl::Encoder.encode(-1.0/0.0)
+    }.should raise_error(Yajl::EncodeError)
+  end
+
+  it "should encode with unicode chars in the key" do
+    hash = {"浅草" => "<- those are unicode"}
+    Yajl::Encoder.encode(hash).should eql("{\"浅草\":\"<- those are unicode\"}")
+  end
+
+  if RUBY_VERSION =~ /^1.9/
+    it "should return a string encoded in utf-8 if Encoding.default_internal is nil" do
+      Encoding.default_internal = nil
+      hash = {"浅草" => "<- those are unicode"}
+      Yajl::Encoder.encode(hash).encoding.should eql(Encoding.find('utf-8'))
+    end
+
+    it "should return a string encoded in utf-8 even if Encoding.default_internal *is* set" do
+      Encoding.default_internal = Encoding.find('utf-8')
+      hash = {"浅草" => "<- those are unicode"}
+      Yajl::Encoder.encode(hash).encoding.should eql(Encoding.default_internal)
+      Encoding.default_internal = Encoding.find('us-ascii')
+      hash = {"浅草" => "<- those are unicode"}
+      Yajl::Encoder.encode(hash).encoding.should eql(Encoding.find('utf-8'))
+    end
+  end
+
+  it "should be able to escape / characters if html_safe is enabled" do
+    unsafe_encoder = Yajl::Encoder.new(:html_safe => false)
+    safe_encoder   = Yajl::Encoder.new(:html_safe => true)
+
+    unsafe_encoder.encode("</script>").should_not eql("\"<\\/script>\"")
+    safe_encoder.encode("</script>").should eql("\"<\\/script>\"")
+  end
+
+  it "should default to *not* escaping / characters" do
+    unsafe_encoder = Yajl::Encoder.new
+    unsafe_encoder.encode("</script>").should_not eql("\"<\\/script>\"")
+  end
+
+  it "return value of #to_json must be a string" do
+    lambda {
+      Yajl::Encoder.encode(TheMindKiller.new)
+    }.should raise_error(TypeError)
+  end
+
+  it "return value of #to_s must be a string" do
+    lambda {
+      Yajl::Encoder.encode(TheMindKillerDuce.new)
+    }.should raise_error(TypeError)
+  end
+end

data/spec/global/global_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+describe "Yajl" do
+  context "dump" do
+    it "should exist as a class-method" do
+      Yajl.should respond_to(:dump)
+    end
+
+    it "should be able to encode to a string" do
+      Yajl.dump({:a => 1234}).should eql('{"a":1234}')
+    end
+
+    it "should be able to encode to an IO" do
+      io = StringIO.new
+      Yajl.dump({:a => 1234}, io)
+      io.rewind
+      io.read.should eql('{"a":1234}')
+    end
+
+    it "should be able to encode with a block supplied" do
+      Yajl.dump({:a => 1234}) do |chunk|
+        chunk.should eql('{"a":1234}')
+      end
+    end
+  end
+
+  context "load" do
+    it "should exist as a class-method" do
+      Yajl.should respond_to(:load)
+    end
+
+    it "should be able to parse from a string" do
+      Yajl.load('{"a":1234}').should eql({"a" => 1234})
+    end
+
+    it "should be able to parse from an IO" do
+      io = StringIO.new('{"a":1234}')
+      Yajl.load(io).should eql({"a" => 1234})
+    end
+
+    it "should be able to parse from a string with a block supplied" do
+      Yajl.load('{"a":1234}') do |h|
+        h.should eql({"a" => 1234})
+      end
+    end
+
+    it "should be able to parse from an IO with a block supplied" do
+      io = StringIO.new('{"a":1234}')
+      Yajl.load(io) do |h|
+        h.should eql({"a" => 1234})
+      end
+    end
+  end
+end

data/spec/http/fixtures/http.chunked.dump

@@ -0,0 +1,11 @@
+HTTP/1.1 200 OK
+Content-Type: application/json
+Transfer-Encoding: chunked
+
+12f
+{"item": {"name": "generated", "cached_tag_list": "", "updated_at": "2009-03-24T05:25:09Z", "updated_by_id": null, "price": 1.99, "delta": false, "cost": 0.597, "account_id": 16, "unit": null, "import_tag": null, "taxable": true, "id": 1, "created_by_id": null, "description": null, "company_id": 0, "sk
+
+48
+u": "06317-0306", "created_at": "2009-03-24T05:25:09Z", "active": true}}
+
+0