multi_json 1.5.0 → 1.12.1

data/spec/adapter_shared_example.rb

@@ -1,127 +0,0 @@
-shared_examples_for "an adapter" do |adapter|
-
-  before do
-    begin
-      MultiJson.use adapter
-    rescue LoadError
-      pending "Adapter #{adapter} couldn't be loaded (not installed?)"
-    end
-  end
-
-  describe '.dump' do
-    it 'writes decodable JSON' do
-      [
-        {'abc' => 'def'},
-        [1, 2, 3, "4"],
-      ].each do |example|
-        expect(MultiJson.load(MultiJson.dump(example))).to eq example
-      end
-    end
-
-    it 'dumps symbol and fixnum keys as strings' do
-      [
-        [
-          {:foo => {:bar => 'baz'}},
-          {'foo' => {'bar' => 'baz'}},
-        ],
-        [
-          [{:foo => {:bar => 'baz'}}],
-          [{'foo' => {'bar' => 'baz'}}],
-        ],
-        [
-          {:foo => [{:bar => 'baz'}]},
-          {'foo' => [{'bar' => 'baz'}]},
-        ],
-        [
-          {1 => {2 => {3 => 'bar'}}},
-          {'1' => {'2' => {'3' => 'bar'}}}
-        ]
-      ].each do |example, expected|
-        dumped_json = MultiJson.dump(example)
-        expect(MultiJson.load(dumped_json)).to eq expected
-      end
-    end
-
-    it 'dumps rootless JSON' do
-      expect(MultiJson.dump("random rootless string")).to eq "\"random rootless string\""
-      expect(MultiJson.dump(123)).to eq "123"
-    end
-
-    it 'passes options to the adapter' do
-      MultiJson.adapter.should_receive(:dump).with('foo', {:bar => :baz})
-      MultiJson.dump('foo', :bar => :baz)
-    end
-
-    if adapter == 'json_gem' || adapter == 'json_pure'
-      describe 'with :pretty option set to true' do
-        it 'passes default pretty options' do
-          object = 'foo'
-          object.should_receive(:to_json).with(JSON::PRETTY_STATE_PROTOTYPE.to_h)
-          MultiJson.dump(object,:pretty => true)
-        end
-      end
-    end
-
-    it 'dumps custom objects which implement as_json' do
-      expect(MultiJson.dump(TimeWithZone.new)).to eq "\"2005-02-01T15:15:10Z\""
-    end
-
-    it 'allow to dump JSON values' do
-      expect(MultiJson.dump(42)).to eq '42'
-    end
-
-  end
-
-  describe '.load' do
-    it 'properly loads valid JSON' do
-      expect(MultiJson.load('{"abc":"def"}')).to eq({'abc' => 'def'})
-    end
-
-    it 'raises MultiJson::DecodeError on invalid JSON' do
-      expect{MultiJson.load('{"abc"}')}.to raise_error(MultiJson::DecodeError)
-    end
-
-    it 'raises MultiJson::DecodeError with data on invalid JSON' do
-      data = '{invalid}'
-      begin
-        MultiJson.load(data)
-      rescue MultiJson::DecodeError => de
-        expect(de.data).to eq data
-      end
-    end
-
-    it 'stringifys symbol keys when encoding' do
-      dumped_json = MultiJson.dump(:a => 1, :b => {:c => 2})
-      expect(MultiJson.load(dumped_json)).to eq({"a" => 1, "b" => {"c" => 2}})
-    end
-
-    it 'properly loads valid JSON in StringIOs' do
-      json = StringIO.new('{"abc":"def"}')
-      expect(MultiJson.load(json)).to eq({'abc' => 'def'})
-    end
-
-    it 'allows for symbolization of keys' do
-      [
-        [
-          '{"abc":{"def":"hgi"}}',
-          {:abc => {:def => 'hgi'}},
-        ],
-        [
-          '[{"abc":{"def":"hgi"}}]',
-          [{:abc => {:def => 'hgi'}}],
-        ],
-        [
-          '{"abc":[{"def":"hgi"}]}',
-          {:abc => [{:def => 'hgi'}]},
-        ],
-      ].each do |example, expected|
-        expect(MultiJson.load(example, :symbolize_keys => true)).to eq expected
-      end
-    end
-
-    it 'allow to load JSON values' do
-      expect(MultiJson.load('42')).to eq 42
-    end
-
-  end
-end

data/spec/helper.rb

@@ -1,39 +0,0 @@
-def jruby?
-  defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-end
-
-def macruby?
-  defined?(RUBY_ENGINE) && RUBY_ENGINE == 'macruby'
-end
-
-unless ENV['CI'] || macruby?
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter 'spec'
-  end
-end
-
-require 'multi_json'
-require 'rspec'
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end
-
-class MockDecoder
-  def self.load(string, options={})
-    {'abc' => 'def'}
-  end
-
-  def self.dump(string)
-    '{"abc":"def"}'
-  end
-end
-
-class TimeWithZone
-  def to_json(options={})
-    "\"2005-02-01T15:15:10Z\""
-  end
-end

data/spec/multi_json_spec.rb

@@ -1,100 +0,0 @@
-require 'helper'
-require 'adapter_shared_example'
-require 'stringio'
-
-describe 'MultiJson' do
-  context 'adapters' do
-    before do
-      MultiJson.use nil
-    end
-    context 'when no other json implementations are available' do
-      before do
-        @old_map = MultiJson::REQUIREMENT_MAP
-        @old_json = Object.const_get :JSON if Object.const_defined?(:JSON)
-        @old_oj = Object.const_get :Oj if Object.const_defined?(:Oj)
-        @old_yajl = Object.const_get :Yajl if Object.const_defined?(:Yajl)
-        MultiJson::REQUIREMENT_MAP.each_with_index do |(library, adapter), index|
-          MultiJson::REQUIREMENT_MAP[index] = ["foo/#{library}", adapter]
-        end
-        Object.send :remove_const, :JSON if @old_json
-        Object.send :remove_const, :Oj if @old_oj
-        Object.send :remove_const, :Yajl if @old_yajl
-      end
-
-      after do
-        @old_map.each_with_index do |(library, adapter), index|
-          MultiJson::REQUIREMENT_MAP[index] = [library, adapter]
-        end
-        Object.const_set :JSON, @old_json if @old_json
-        Object.const_set :Oj, @old_oj if @old_oj
-        Object.const_set :Yajl, @old_yajl if @old_yajl
-      end
-
-      it 'defaults to ok_json if no other json implementions are available' do
-        expect(MultiJson.default_adapter).to eq :ok_json
-      end
-
-      it 'prints a warning' do
-        Kernel.should_receive(:warn).with(/warning/i)
-        MultiJson.default_adapter
-      end
-    end
-
-    it 'defaults to the best available gem' do
-      # Clear cache variable already set by previous tests
-      MultiJson.send(:remove_instance_variable, :@adapter)
-      unless jruby?
-        require 'oj'
-        expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::Oj'
-      else
-        require 'json'
-        expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::JsonGem'
-      end
-    end
-
-    it 'is settable via a symbol' do
-      MultiJson.use :json_gem
-      expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::JsonGem'
-    end
-
-    it 'is settable via a class' do
-      MultiJson.use MockDecoder
-      expect(MultiJson.adapter.name).to eq 'MockDecoder'
-    end
-
-    context "using one-shot parser" do
-      before(:each) do
-        require 'multi_json/adapters/json_pure'
-        MultiJson::Adapters::JsonPure.should_receive(:dump).exactly(1).times.and_return('dump_something')
-        MultiJson::Adapters::JsonPure.should_receive(:load).exactly(1).times.and_return('load_something')
-      end
-
-      it "should use the defined parser just for the call" do
-        MultiJson.use :json_gem
-        expect(MultiJson.dump('', :adapter => :json_pure)).to eq 'dump_something'
-        expect(MultiJson.load('', :adapter => :json_pure)).to eq 'load_something'
-        expect(MultiJson.adapter.name).to eq "MultiJson::Adapters::JsonGem"
-      end
-    end
-  end
-
-  it 'can set adapter for a block' do
-    MultiJson.use :ok_json
-    MultiJson.with_adapter(:json_pure) do
-      expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::JsonPure'
-    end
-    MultiJson.with_engine(:yajl) do
-      expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::Yajl'
-    end
-    expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::OkJson'
-  end
-
-  %w(json_gem json_pure nsjsonserialization oj ok_json yajl).each do |adapter|
-    next if !macruby? && adapter == 'nsjsonserialization'
-    next if jruby? && (adapter == 'oj' || adapter == 'yajl')
-
-    context adapter do
-      it_behaves_like "an adapter", adapter
-    end
-  end
-end