oortle-yajl-ruby 0.5.8

data/spec/http/http_spec.rb

@@ -0,0 +1,158 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+require 'yajl/bzip2'
+require 'yajl/gzip'
+require 'yajl/deflate'
+require 'yajl/http_stream'
+
+def parse_off_headers(io)
+  io.each_line do |line|
+    if line == "\r\n" # end of the headers
+      break
+    end
+  end
+end
+
+describe "Yajl HTTP GET request" do
+  before(:all) do
+    raw = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.raw.dump'), 'r')
+    parse_off_headers(raw)
+    @template_hash = Yajl::Parser.parse(raw)
+    
+    raw.rewind
+    parse_off_headers(raw)
+    @template_hash_symbolized = Yajl::Parser.parse(raw, :symbolize_keys => true)
+    
+    @deflate = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.deflate.dump'), 'r')
+    @gzip = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.gzip.dump'), 'r')
+  end
+  
+  after(:each) do
+    @file_path = nil
+  end
+  
+  def prepare_mock_request_dump(format=:raw)
+    @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.#{format}.dump"), 'r')
+    @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.#{format}.dump")
+    TCPSocket.should_receive(:new).and_return(@request)
+    @request.should_receive(:write)
+    @uri.should_receive(:host).at_least(2).times
+    @uri.should_receive(:port)
+    @uri.should_receive(:path)
+    @uri.should_receive(:query)
+    @uri.should_receive(:userinfo)
+  end
+  
+  it "should parse a raw response" do
+    prepare_mock_request_dump :raw
+    @template_hash.should == Yajl::HttpStream.get(@uri)
+  end
+  
+  it "should parse a raw response and symbolize keys" do
+    prepare_mock_request_dump :raw
+    @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+  end
+  
+  it "should parse a bzip2 compressed response" do
+    prepare_mock_request_dump :bzip2
+    @template_hash.should == Yajl::HttpStream.get(@uri)
+  end
+  
+  it "should parse a bzip2 compressed response and symbolize keys" do
+    prepare_mock_request_dump :bzip2
+    @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+  end
+  
+  it "should parse a deflate compressed response" do
+    prepare_mock_request_dump :deflate
+    @template_hash.should == Yajl::HttpStream.get(@uri)
+  end
+  
+  it "should parse a deflate compressed response and symbolize keys" do
+    prepare_mock_request_dump :deflate
+    @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+  end
+  
+  it "should parse a gzip compressed response" do
+    prepare_mock_request_dump :gzip
+    @template_hash.should == Yajl::HttpStream.get(@uri)
+  end
+  
+  it "should parse a gzip compressed response and symbolize keys" do
+    prepare_mock_request_dump :gzip
+    @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+  end
+end
+
+describe "Yajl HTTP POST request" do
+  before(:all) do
+    raw = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.raw.dump'), 'r')
+    parse_off_headers(raw)
+    @template_hash = Yajl::Parser.parse(raw)
+    
+    raw.rewind
+    parse_off_headers(raw)
+    @template_hash_symbolized = Yajl::Parser.parse(raw, :symbolize_keys => true)
+    
+    @deflate = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.deflate.dump'), 'r')
+    @gzip = File.new(File.expand_path(File.dirname(__FILE__) + '/fixtures/http.gzip.dump'), 'r')
+
+    @params = {:a => 1, :b => 'has spaces'}
+  end
+  
+  after(:each) do
+    @file_path = nil
+  end
+  
+  def prepare_mock_request_dump(format=:raw)
+    @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.#{format}.dump"), 'r')
+    @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.#{format}.dump")
+    TCPSocket.should_receive(:new).and_return(@request)
+    @request.should_receive(:write)
+    @uri.should_receive(:host).at_least(2).times
+    @uri.should_receive(:port)
+    @uri.should_receive(:path)
+    @uri.should_receive(:query)
+    @uri.should_receive(:userinfo)
+  end
+  
+  it "should parse a raw response" do
+    prepare_mock_request_dump :raw
+    @template_hash.should == Yajl::HttpStream.post(@uri, @params)
+  end
+  
+  it "should parse a raw response and symbolize keys" do
+    prepare_mock_request_dump :raw
+    @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @params, :symbolize_keys => true)
+  end
+  
+  it "should parse a bzip2 compressed response" do
+    prepare_mock_request_dump :bzip2
+    @template_hash.should == Yajl::HttpStream.post(@uri, @params)
+  end
+  
+  it "should parse a bzip2 compressed response and symbolize keys" do
+    prepare_mock_request_dump :bzip2
+    @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @params, :symbolize_keys => true)
+  end
+  
+  it "should parse a deflate compressed response" do
+    prepare_mock_request_dump :deflate
+    @template_hash.should == Yajl::HttpStream.post(@uri, @params)
+  end
+  
+  it "should parse a deflate compressed response and symbolize keys" do
+    prepare_mock_request_dump :deflate
+    @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @params, :symbolize_keys => true)
+  end
+  
+  it "should parse a gzip compressed response" do
+    prepare_mock_request_dump :gzip
+    @template_hash.should == Yajl::HttpStream.post(@uri, @params)
+  end
+  
+  it "should parse a gzip compressed response and symbolize keys" do
+    prepare_mock_request_dump :gzip
+    @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @params, :symbolize_keys => true)
+  end
+end

data/spec/json_gem_compatibility/compatibility_spec.rb

@@ -0,0 +1,178 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+class Dummy; end
+
+describe "JSON Gem compatability API" do
+  it "shoud not mixin #to_json on base objects until compatability has been enabled" do
+    d = Dummy.new
+    
+    d.respond_to?(:to_json).should_not be_true
+    "".respond_to?(:to_json).should_not be_true
+    1.respond_to?(:to_json).should_not be_true
+    "1.5".to_f.respond_to?(:to_json).should_not be_true
+    [].respond_to?(:to_json).should_not be_true
+    {:foo => "bar"}.respond_to?(:to_json).should_not be_true
+    true.respond_to?(:to_json).should_not be_true
+    false.respond_to?(:to_json).should_not be_true
+    nil.respond_to?(:to_json).should_not be_true
+  end
+  
+  it "should mixin #to_json on base objects after compatability has been enabled" do
+    Yajl::Encoder.enable_json_gem_compatability
+    d = Dummy.new
+    
+    d.respond_to?(:to_json).should be_true
+    "".respond_to?(:to_json).should be_true
+    1.respond_to?(:to_json).should be_true
+    "1.5".to_f.respond_to?(:to_json).should be_true
+    [].respond_to?(:to_json).should be_true
+    {:foo => "bar"}.respond_to?(:to_json).should be_true
+    true.respond_to?(:to_json).should be_true
+    false.respond_to?(:to_json).should be_true
+    nil.respond_to?(:to_json).should be_true
+  end
+  
+  it "should require yajl/json_gem to enable the compatability API" do
+    require 'yajl/json_gem'
+    
+    defined?(JSON).should be_true
+    
+    JSON.respond_to?(:parse).should be_true
+    JSON.respond_to?(:generate).should be_true
+    JSON.respond_to?(:pretty_generate).should be_true
+    JSON.respond_to?(:load).should be_true
+    JSON.respond_to?(:dump).should be_true
+  end
+  
+  it "should allow default parsing options be set with JSON.default_options" do
+    default = JSON.default_options[:symbolize_keys]
+    JSON.parse('{"foo": 1234}').should === {"foo" => 1234}
+    JSON.default_options[:symbolize_keys] = true
+    JSON.parse('{"foo": 1234}').should === {:foo => 1234}
+    JSON.default_options[:symbolize_keys] = default # ensure the rest of the test cases expect the default
+  end
+  
+  context "ported tests for Unicode" do
+    it "should be able to encode and parse unicode" do
+      pending if RUBY_VERSION.include?('1.9') # FIXME: Some string encoding problem with 1.9
+      '""'.should eql(''.to_json)
+      '"\\b"'.should eql("\b".to_json)
+      '"\u0001"'.should eql(0x1.chr.to_json)
+      '"\u001F"'.should eql(0x1f.chr.to_json)
+      '" "'.should eql(' '.to_json)
+      "\"#{0x7f.chr}\"".should eql(0x7f.chr.to_json)
+      utf8 = [ "© ≠ €! \01" ]
+      json = '["© ≠ €! \u0001"]'
+      json.should eql(utf8.to_json)
+      utf8.should eql(JSON.parse(json))
+      utf8 = ["\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212"]
+      json = "[\"あいうえお\"]"
+      json.should eql(utf8.to_json)
+      utf8.should eql(JSON.parse(json))
+      utf8 = ['საქართველო']
+      json = "[\"საქართველო\"]"
+      json.should eql(utf8.to_json)
+      utf8.should eql(JSON.parse(json))
+      '["Ã"]'.should eql(JSON.generate(["Ã"]))
+      ["€"].should eql(JSON.parse('["\u20ac"]'))
+      utf8_str = "\xf0\xa0\x80\x81"
+      utf8 = [utf8_str]
+      json = "[\"#{utf8_str}\"]"
+      json.should eql(JSON.generate(utf8))
+      utf8.should eql(JSON.parse(json))
+    end
+  end
+  
+  context "ported tests for generation" do
+    before(:all) do
+      @hash = {
+        'a' => 2,
+        'b' => 3.141,
+        'c' => 'c',
+        'd' => [ 1, "b", 3.14 ],
+        'e' => { 'foo' => 'bar' },
+        'g' => "blah",
+        'h' => 1000.0,
+        'i' => 0.001
+      }
+      
+      @json2 = '{"a":2,"b":3.141,"c":"c","d":[1,"b",3.14],"e":{"foo":"bar"},"g":"blah","h":1000.0,"i":0.001}'
+      
+      @json3 = %{
+        {
+          "a": 2,
+          "b": 3.141,
+          "c": "c",
+          "d": [1, "b", 3.14],
+          "e": {"foo": "bar"},
+          "g": "blah",
+          "h": 1000.0,
+          "i": 0.001
+        }
+      }.chomp
+    end
+    
+    it "should be able to unparse" do
+      json = JSON.generate(@hash)
+      JSON.parse(@json2).should == JSON.parse(json)
+      parsed_json = JSON.parse(json)
+      @hash.should == parsed_json
+      json = JSON.generate({1=>2})
+      '{"1":2}'.should eql(json)
+      parsed_json = JSON.parse(json)
+      {"1"=>2}.should == parsed_json
+    end
+    
+    it "should be able to unparse pretty" do
+      json = JSON.pretty_generate(@hash)
+      JSON.parse(@json3).should == JSON.parse(json)
+      parsed_json = JSON.parse(json)
+      @hash.should == parsed_json
+      json = JSON.pretty_generate({1=>2})
+      test = "{\n  \"1\": 2\n}".chomp
+      test.should == json
+      parsed_json = JSON.parse(json)
+      {"1"=>2}.should == parsed_json
+    end
+  end
+  
+  context "ported fixture tests" do
+    fixtures = File.join(File.dirname(__FILE__), '../parsing/fixtures/*.json')
+    passed, failed = Dir[fixtures].partition { |f| f['pass'] }
+    JSON_PASSED = passed.inject([]) { |a, f| a << [ f, File.read(f) ] }.sort
+    JSON_FAILED = failed.inject([]) { |a, f| a << [ f, File.read(f) ] }.sort
+    
+    JSON_FAILED.each do |name, source|
+      it "should not be able to parse #{File.basename(name)} as an IO" do
+          lambda {
+            JSON.parse(StringIO.new(source))
+          }.should raise_error(Yajl::ParseError)
+      end
+    end
+
+    JSON_FAILED.each do |name, source|
+      it "should not be able to parse #{File.basename(name)} as a string" do
+          lambda {
+            JSON.parse(source)
+          }.should raise_error(Yajl::ParseError)
+      end
+    end
+
+    JSON_PASSED.each do |name, source|
+      it "should be able to parse #{File.basename(name)} as an IO" do
+          lambda {
+            JSON.parse(StringIO.new(source))
+          }.should_not raise_error(Yajl::ParseError)
+      end
+    end
+
+    JSON_PASSED.each do |name, source|
+      it "should be able to parse #{File.basename(name)} as a string" do
+          lambda {
+            JSON.parse(source)
+          }.should_not raise_error(Yajl::ParseError)
+      end
+    end
+  end
+end

data/spec/parsing/active_support_spec.rb

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+describe "ActiveSupport test cases" do
+  TESTS = {
+    %q({"returnTo":{"\/categories":"\/"}})        => {"returnTo" => {"/categories" => "/"}},
+    %q({"return\\"To\\":":{"\/categories":"\/"}}) => {"return\"To\":" => {"/categories" => "/"}},
+    %q({"returnTo":{"\/categories":1}})          => {"returnTo" => {"/categories" => 1}},
+    %({"returnTo":[1,"a"]})                    => {"returnTo" => [1, "a"]},
+    %({"returnTo":[1,"\\"a\\",", "b"]})        => {"returnTo" => [1, "\"a\",", "b"]},
+    %({"a": "'", "b": "5,000"})                  => {"a" => "'", "b" => "5,000"},
+    %({"a": "a's, b's and c's", "b": "5,000"})   => {"a" => "a's, b's and c's", "b" => "5,000"},
+    # multibyte
+    %({"matzue": "松江", "asakusa": "浅草"}) => {"matzue" => "松江", "asakusa" => "浅草"},
+    %({"a": "2007-01-01"})                       => {'a' => "2007-01-01"}, 
+    %({"a": "2007-01-01 01:12:34 Z"})            => {'a' => "2007-01-01 01:12:34 Z"}, 
+    # no time zone
+    %({"a": "2007-01-01 01:12:34"})              => {'a' => "2007-01-01 01:12:34"}, 
+    # needs to be *exact*
+    %({"a": " 2007-01-01 01:12:34 Z "})          => {'a' => " 2007-01-01 01:12:34 Z "},
+    %({"a": "2007-01-01 : it's your birthday"})  => {'a' => "2007-01-01 : it's your birthday"},
+    %([])    => [],
+    %({})    => {},
+    %({"a":1})     => {"a" => 1},
+    %({"a": ""})    => {"a" => ""},
+    %({"a":"\\""}) => {"a" => "\""},
+    %({"a": null})  => {"a" => nil},
+    %({"a": true})  => {"a" => true},
+    %({"a": false}) => {"a" => false},
+    %q({"a": "http:\/\/test.host\/posts\/1"}) => {"a" => "http://test.host/posts/1"},
+    %q({"a": "\u003cunicode\u0020escape\u003e"}) => {"a" => "<unicode escape>"},
+    %q({"a": "\\\\u0020skip double backslashes"}) => {"a" => "\\u0020skip double backslashes"},
+    %q({"a": "\u003cbr /\u003e"}) => {'a' => "<br />"},
+    %q({"b":["\u003ci\u003e","\u003cb\u003e","\u003cu\u003e"]}) => {'b' => ["<i>","<b>","<u>"]}
+  }
+  
+  TESTS.each do |json, expected|
+    it "should be able to parse #{json} as an IO" do
+      lambda {
+        Yajl::Parser.parse(StringIO.new(json)).should == expected
+      }.should_not raise_error(Yajl::ParseError)
+    end
+  end
+  
+  TESTS.each do |json, expected|
+    it "should be able to parse #{json} as a string" do
+      lambda {
+        Yajl::Parser.parse(json).should == expected
+      }.should_not raise_error(Yajl::ParseError)
+    end
+  end
+
+  it "should fail parsing {: 1} as an IO" do
+    lambda {
+      Yajl::Parser.parse(StringIO.new("{: 1}"))
+    }.should raise_error(Yajl::ParseError)
+  end
+  
+  it "should fail parsing {: 1} as a string" do
+    lambda {
+      Yajl::Parser.parse("{: 1}")
+    }.should raise_error(Yajl::ParseError)
+  end
+end

data/spec/parsing/chunked_spec.rb

@@ -0,0 +1,98 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+require 'stringio'
+
+describe "Chunked parser" do
+  before(:all) do
+    @final = [{"abc" => 123}, {"def" => 456}]
+  end
+  
+  before(:each) do
+    @callback = lambda { |hash|
+      # no-op
+    }
+    @parser = Yajl::Parser.new
+    @parser.on_parse_complete = @callback
+  end
+  
+  it "should parse a single chunk" do
+    @callback.should_receive(:call).with(@final)
+    @parser << '[{"abc": 123},{"def": 456}]'
+  end
+  
+  it "should parse a single chunk, 3 times" do
+    @callback.should_receive(:call).with(@final).exactly(3).times
+    @parser << '[{"abc": 123},{"def": 456}]'
+    @parser << '[{"abc": 123},{"def": 456}]'
+    @parser << '[{"abc": 123},{"def": 456}]'
+  end
+  
+  it "should parse in two chunks" do
+    @callback.should_receive(:call).with(@final)
+    @parser << '[{"abc": 123},'
+    @parser << '{"def": 456}]'
+  end
+  
+  it "should parse in 2 chunks, twice" do
+    @callback.should_receive(:call).with(@final).exactly(2).times
+    @parser << '[{"abc": 123},'
+    @parser << '{"def": 456}]'
+    @parser << '[{"abc": 123},'
+    @parser << '{"def": 456}]'
+  end
+  
+  it "should parse 2 JSON strings, in 3 chunks" do
+    @callback.should_receive(:call).with(@final).exactly(2).times
+    @parser << '[{"abc": 123},'
+    @parser << '{"def": 456}][{"abc": 123},{"def":'
+    @parser << ' 456}]'
+  end
+  
+  it "should parse 2 JSON strings in 1 chunk" do
+    @callback.should_receive(:call).with(@final).exactly(2).times
+    @parser << '[{"abc": 123},{"def": 456}][{"abc": 123},{"def": 456}]'
+  end
+  
+  it "should parse 2 JSON strings from an IO" do
+    @callback.should_receive(:call).with(@final).exactly(2).times
+    @parser.parse(StringIO.new('[{"abc": 123},{"def": 456}][{"abc": 123},{"def": 456}]'))
+  end
+  
+  it "should parse a JSON string an IO and fire callback once" do
+    @callback.should_receive(:call).with(@final)
+    @parser.parse(StringIO.new('[{"abc": 123},{"def": 456}]'))
+  end
+  
+  it "should parse twitter_stream.json and fire callback 430 times" do
+    path = File.expand_path(File.dirname(__FILE__) + '/../../benchmark/subjects/twitter_stream.json')
+    json = File.new(path, 'r')
+    @callback.should_receive(:call).exactly(430).times
+    lambda {
+      @parser.parse(json)
+    }.should_not raise_error(Yajl::ParseError)
+  end
+  
+  it "should parse twitter_stream.json and fire callback 430 times, with a block as the callback" do
+    path = File.expand_path(File.dirname(__FILE__) + '/../../benchmark/subjects/twitter_stream.json')
+    json = File.new(path, 'r')
+    @callback.should_receive(:call).exactly(0).times
+    @parser.on_parse_complete = nil
+    lambda {
+      times = 0
+      @parser.parse(json) do |hsh|
+        times += 1
+      end
+      times.should eql(430)
+    }.should_not raise_error(Yajl::ParseError)
+  end
+  
+  it "should raise a Yajl::ParseError error if multiple JSON strings were found when no on_parse_complete callback assigned" do
+    path = File.expand_path(File.dirname(__FILE__) + '/../../benchmark/subjects/twitter_stream.json')
+    json = File.new(path, 'r')
+    @parser.on_parse_complete = nil
+    @callback.should_receive(:call).exactly(0).times
+    lambda {
+      @parser.parse(json)
+    }.should raise_error(Yajl::ParseError)
+  end
+end