multi_json 1.6.1 → 1.7.0

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+1.7.0
+-----
+* [Add load_options/dump_options to MultiJson](https://github.com/intridea/multi_json/commit/a153956be6b0df06ea1705ce3c1ff0b5b0e27ea5)
+* [MultiJson does not modify arguments](https://github.com/intridea/multi_json/commit/58525b01c4c2f6635ba2ac13d6fd987b79f3962f)
+* [Enable quirks_mode by default for json_gem/json_pure adapters](https://github.com/intridea/multi_json/commit/1fd4e6635c436515b7d7d5a0bee4548de8571520)
+* [Add JrJackson adapter](https://github.com/intridea/multi_json/commit/4dd86fa96300aaaf6d762578b9b31ea82adb056d)
+* [Raise ArgumentError on bad adapter input](https://github.com/intridea/multi_json/commit/911a3756bdff2cb5ac06497da3fa3e72199cb7ad)
+
 1.6.1
 -----
 * [Revert "Use JSON.generate instead of #to_json"](https://github.com/intridea/multi_json/issues/86)

data/Gemfile

@@ -15,6 +15,7 @@ platforms :ruby, :mswin, :mingw do
 end
 platforms :jruby do
   gem 'gson', '>= 0.6', :require => nil
+  gem 'jrjackson', :require => nil
 end
 
 group :development do
@@ -24,6 +25,7 @@ group :development do
 end
 
 group :test do
+  gem 'coveralls', :require => false
   gem 'rspec', '>= 2.11'
   gem 'simplecov', :require => false
 end

data/README.md

@@ -1,13 +1,16 @@
 # MultiJSON
+
 [![Gem Version](https://badge.fury.io/rb/multi_json.png)][gem]
 [![Build Status](https://secure.travis-ci.org/intridea/multi_json.png?branch=master)][travis]
 [![Dependency Status](https://gemnasium.com/intridea/multi_json.png?travis)][gemnasium]
 [![Code Climate](https://codeclimate.com/github/intridea/multi_json.png)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/intridea/multi_json/badge.png?branch=master)][coveralls]
 
 [gem]: https://rubygems.org/gems/multi_json
 [travis]: http://travis-ci.org/intridea/multi_json
 [gemnasium]: https://gemnasium.com/intridea/multi_json
 [codeclimate]: https://codeclimate.com/github/intridea/multi_json
+[coveralls]: https://coveralls.io/r/intridea/multi_json
 
 Lots of Ruby libraries parse JSON and everyone has their favorite JSON coder.
 Instead of choosing a single JSON coder and forcing users of your library to be
@@ -49,6 +52,7 @@ MultiJSON falls back to [OkJson][], a simple, vendorable JSON parser.
 * [JSON Pure](https://github.com/flori/json) A Ruby variant of the JSON gem
 * [NSJSONSerialization](https://developer.apple.com/library/ios/#documentation/Foundation/Reference/NSJSONSerialization_Class/Reference/Reference.html) Wrapper for Apple's NSJSONSerialization in the Cocoa Framework (MacRuby only)
 * [gson.rb](https://github.com/avsej/gson.rb) A Ruby wrapper for google-gson library (JRuby only)
+* [JrJackson](https://github.com/guyboertje/jrjackson) JRuby wrapper for Jackson (JRuby only)
 * [OkJson][okjson] A simple, vendorable JSON parser
 
 ## Supported Ruby Versions

data/lib/multi_json.rb

@@ -1,4 +1,7 @@
+require 'multi_json/options'
+
 module MultiJson
+  include Options
   extend self
 
   class LoadError < StandardError
@@ -11,15 +14,24 @@ module MultiJson
   end
   DecodeError = LoadError # Legacy support
 
+  # Since `default_options` is deprecated, the
+  # reader is aliased to `dump_options` and the
+  # writer sets both `dump_options` and `load_options`
+  alias default_options dump_options
+
+  def default_options=(value)
+    Kernel.warn "MultiJson.default_options setter is deprecated\n" +
+      "Use MultiJson.load_options and MultiJson.dump_options instead"
 
-  @default_options = {}
-  attr_accessor :default_options
+    self.load_options = self.dump_options = value
+  end
 
   REQUIREMENT_MAP = [
     ['oj',        :oj],
     ['yajl',      :yajl],
     ['json',      :json_gem],
     ['gson',      :gson],
+    ['jrjackson', :jrjackson],
     ['json/pure', :json_pure]
   ]
 
@@ -45,8 +57,7 @@ module MultiJson
     Kernel.warn '[WARNING] MultiJson is using the default adapter (ok_json). We recommend loading a different JSON library to improve performance.'
     :ok_json
   end
-  # :nodoc:
-  alias :default_engine :default_adapter
+  alias default_engine default_adapter
 
   # Get the current adapter class.
   def adapter
@@ -56,8 +67,7 @@ module MultiJson
 
     @adapter
   end
-  # :nodoc:
-  alias :engine :adapter
+  alias engine adapter
 
   # Set the JSON parser utilizing a symbol, string, or class.
   # Supported by default are:
@@ -72,9 +82,8 @@ module MultiJson
   def use(new_adapter)
     @adapter = load_adapter(new_adapter)
   end
-  alias :adapter= :use
-  # :nodoc:
-  alias :engine= :use
+  alias adapter= use
+  alias engine= use
 
   def load_adapter(new_adapter)
     case new_adapter
@@ -86,8 +95,10 @@ module MultiJson
     when Class, Module
       new_adapter
     else
-      raise "Did not recognize your adapter specification. Please specify either a symbol or a class."
+      raise NameError
     end
+  rescue NameError, ::LoadError
+    raise ArgumentError, 'Did not recognize your adapter specification.'
   end
 
   # Decode a JSON string into Ruby.
@@ -95,7 +106,7 @@ module MultiJson
   # <b>Options</b>
   #
   # <tt>:symbolize_keys</tt> :: If true, will use symbols instead of strings for the keys.
-  # <tt>:adapter</tt> :: If set, the selected engine will be used just for the call.
+  # <tt>:adapter</tt> :: If set, the selected adapter will be used for this call.
   def load(string, options={})
     adapter = current_adapter(options)
     begin
@@ -104,11 +115,10 @@ module MultiJson
       raise LoadError.new(exception.message, exception.backtrace, string)
     end
   end
-  # :nodoc:
-  alias :decode :load
+  alias decode load
 
-  def current_adapter(options)
-    if new_adapter = (options || {}).delete(:adapter)
+  def current_adapter(options={})
+    if new_adapter = options[:adapter]
       load_adapter(new_adapter)
     else
       adapter
@@ -117,12 +127,9 @@ module MultiJson
 
   # Encodes a Ruby object as JSON.
   def dump(object, options={})
-    options = default_options.merge(options)
-    adapter = current_adapter(options)
-    adapter.dump(object, options)
+    current_adapter(options).dump(object, options)
   end
-  # :nodoc:
-  alias :encode :dump
+  alias encode dump
 
   #  Executes passed block using specified adapter.
   def with_adapter(new_adapter)
@@ -131,7 +138,6 @@ module MultiJson
   ensure
     self.adapter = old_adapter
   end
-  # :nodoc:
-  alias :with_engine :with_adapter
+  alias with_engine with_adapter
 
 end

data/lib/multi_json/adapter.rb

@@ -0,0 +1,43 @@
+require 'singleton'
+require 'multi_json/options'
+
+module MultiJson
+  class Adapter
+    extend Options
+    include Singleton
+    class << self
+
+      def defaults(action, value)
+        metaclass = class << self; self; end
+
+        metaclass.instance_eval do
+          define_method("default_#{action}_options"){ value }
+        end
+      end
+
+      def load(string, options={})
+        instance.load(string, collect_load_options(string, options))
+      end
+
+      def dump(object, options={})
+        instance.dump(object, collect_dump_options(object, options))
+      end
+
+    protected
+
+      def collect_load_options(string, options)
+        collect_options :load_options, options, [ string, options ]
+      end
+
+      def collect_dump_options(object, options)
+        collect_options :dump_options, options, [ object, options ]
+      end
+
+      def collect_options(method, overrides, args)
+        global, local = *[MultiJson, self].map{ |r| r.send(method, *args) }
+        local.merge(global).merge(overrides)
+      end
+
+    end
+  end
+end

data/lib/multi_json/adapters/gson.rb

@@ -1,18 +1,17 @@
 require 'gson' unless defined?(::Gson)
+require 'multi_json/adapter'
 
 module MultiJson
   module Adapters
     # Use the gson.rb library to dump/load.
-    module Gson
-      extend self
-
+    class Gson < Adapter
       ParseError = ::Gson::DecodeError
 
-      def load(string, options={}) #:nodoc:
+      def load(string, options={})
         ::Gson::Decoder.new(options).decode(string)
       end
 
-      def dump(object, options={}) #:nodoc:
+      def dump(object, options={})
         ::Gson::Encoder.new(options).encode(object)
       end
     end

data/lib/multi_json/adapters/jrjackson.rb

@@ -0,0 +1,22 @@
+require 'jrjackson_r' unless defined?(::JrJackson)
+require 'multi_json/adapter'
+require 'multi_json/convertible_hash_keys'
+
+module MultiJson
+  module Adapters
+    class Jrjackson < Adapter
+      include ConvertibleHashKeys
+      ParseError = ::Java::OrgCodehausJackson::JsonParseException
+
+      def load(string, options={})
+        string = string.read if string.respond_to?(:read)
+        result = ::JrJackson::Json.parse(string)
+        options[:symbolize_keys] ? symbolize_keys(result) : result
+      end
+
+      def dump(object, options={})
+        ::JrJackson::Json.generate(stringify_keys(object))
+      end
+    end
+  end
+end

data/lib/multi_json/adapters/json_common.rb

@@ -1,35 +1,25 @@
+require 'multi_json/adapter'
+
 module MultiJson
   module Adapters
-    module JsonCommon
+    class JsonCommon < Adapter
+      defaults :load, :create_additions => false, :quirks_mode => true
+
       def load(string, options={})
         string = string.read if string.respond_to?(:read)
-        ::JSON.parse("[#{string}]", process_load_options!(options)).first
-      end
-
-      def dump(object, options={})
-        object.to_json(process_dump_options!(options))
-      end
 
-    protected
-
-      def process_load_options!(options={})
-        process_options!({:create_additions => false}, options) do |opts|
-          opts.merge!(:symbolize_names => true) if options.delete(:symbolize_keys)
+        if string.respond_to?(:force_encoding)
+          string = string.dup.force_encoding(::Encoding::ASCII_8BIT)
         end
-      end
 
-      def process_dump_options!(options={})
-        process_options!({}, options) do |opts|
-          opts.merge!(::JSON::PRETTY_STATE_PROTOTYPE.to_h) if options.delete(:pretty)
-        end
+        options[:symbolize_names] = true if options.delete(:symbolize_keys)
+        ::JSON.parse(string, options)
       end
 
-      def process_options!(default_options, options)
-        return default_options if options.empty?
-        yield default_options
-        default_options.merge!(options)
+      def dump(object, options={})
+        options.merge!(::JSON::PRETTY_STATE_PROTOTYPE.to_h) if options.delete(:pretty)
+        object.to_json(options)
       end
-
     end
   end
-end
+end

data/lib/multi_json/adapters/json_gem.rb

@@ -4,9 +4,8 @@ require 'multi_json/adapters/json_common'
 module MultiJson
   module Adapters
     # Use the JSON gem to dump/load.
-    module JsonGem
+    class JsonGem < JsonCommon
       ParseError = ::JSON::ParserError
-      extend JsonCommon
     end
   end
 end

data/lib/multi_json/adapters/json_pure.rb

@@ -4,9 +4,8 @@ require 'multi_json/adapters/json_common'
 module MultiJson
   module Adapters
     # Use JSON pure to dump/load.
-    module JsonPure
+    class JsonPure < JsonCommon
       ParseError = ::JSON::ParserError
-      extend JsonCommon
     end
   end
 end

data/lib/multi_json/adapters/nsjsonserialization.rb

@@ -3,8 +3,7 @@ require 'multi_json/adapters/ok_json'
 
 module MultiJson
   module Adapters
-    module Nsjsonserialization
-      extend self, MultiJson::Adapters::OkJson
+    class Nsjsonserialization < MultiJson::Adapters::OkJson
       ParseError = ::MultiJson::OkJson::Error
 
       def load(string, options={})

data/lib/multi_json/adapters/oj.rb

@@ -1,12 +1,12 @@
 require 'oj' unless defined?(::Oj)
+require 'multi_json/adapter'
 
 module MultiJson
   module Adapters
     # Use the Oj library to dump/load.
-    module Oj
-      extend self
-
-      DEFAULT_OPTIONS = {:mode => :compat, :time_format => :ruby}.freeze
+    class Oj < Adapter
+      defaults :load, :mode => :strict
+      defaults :dump, :mode => :compat, :time_format => :ruby
 
       ParseError = if defined?(::Oj::ParseError)
         ::Oj::ParseError
@@ -14,15 +14,14 @@ module MultiJson
         SyntaxError
       end
 
-      def load(string, options={}) #:nodoc:
-        options.merge!(:symbol_keys => options[:symbolize_keys])
-        options[:mode] = :strict
-        ::Oj.load(string, DEFAULT_OPTIONS.merge(options))
+      def load(string, options={})
+        options[:symbol_keys] = true if options.delete(:symbolize_keys)
+        ::Oj.load(string, options)
       end
 
-      def dump(object, options={}) #:nodoc:
+      def dump(object, options={})
         options.merge!(:indent => 2) if options[:pretty]
-        ::Oj.dump(object, DEFAULT_OPTIONS.merge(options))
+        ::Oj.dump(object, options)
       end
     end
   end

data/lib/multi_json/adapters/ok_json.rb

@@ -1,58 +1,22 @@
+require 'multi_json/adapter'
+require 'multi_json/convertible_hash_keys'
 require 'multi_json/vendor/okjson'
 
 module MultiJson
   module Adapters
-    module OkJson
-      extend self
-
+    class OkJson < Adapter
+      include ConvertibleHashKeys
       ParseError = ::MultiJson::OkJson::Error
 
-      def load(string, options={}) #:nodoc:
+      def load(string, options={})
         string = string.read if string.respond_to?(:read)
         result = ::MultiJson::OkJson.decode("[#{string}]").first
         options[:symbolize_keys] ? symbolize_keys(result) : result
       end
 
-      def dump(object, options={}) #:nodoc:
+      def dump(object, options={})
         ::MultiJson::OkJson.valenc(stringify_keys(object))
       end
-
-      def symbolize_keys(object) #:nodoc:
-        prepare_object(object) do |key|
-          key.is_a?(String) ? key.to_sym : key
-        end
-      end
-
-      def stringify_keys(object) #:nodoc:
-        prepare_object(object) do |key|
-          key.respond_to?(:to_s) ? key.to_s : key
-        end
-      end
-
-      def prepare_object(object, &key_modifier) #:nodoc:
-        case object
-        when Array
-          object.map do |value|
-            prepare_object(value, &key_modifier)
-          end
-        when Hash
-          object.inject({}) do |result, (key, value)|
-            new_key   = key_modifier.call(key)
-            new_value = prepare_object(value, &key_modifier)
-            result.merge! new_key => new_value
-          end
-        when String, Numeric, true, false, nil
-          object
-        else
-          if object.respond_to?(:to_json)
-            object
-          elsif object.respond_to?(:to_s)
-            object.to_s
-          else
-            object
-          end
-        end
-      end
     end
   end
 end

data/lib/multi_json/adapters/yajl.rb

@@ -1,18 +1,17 @@
 require 'yajl' unless defined?(::Yajl)
+require 'multi_json/adapter'
 
 module MultiJson
   module Adapters
     # Use the Yajl-Ruby library to dump/load.
-    module Yajl
-      extend self
-
+    class Yajl < Adapter
       ParseError = ::Yajl::ParseError
 
-      def load(string, options={}) #:nodoc:
+      def load(string, options={})
         ::Yajl::Parser.new(:symbolize_keys => options[:symbolize_keys]).parse(string)
       end
 
-      def dump(object, options={}) #:nodoc:
+      def dump(object, options={})
         ::Yajl::Encoder.encode(object, options)
       end
     end

data/lib/multi_json/convertible_hash_keys.rb

@@ -0,0 +1,43 @@
+module MultiJson
+  module ConvertibleHashKeys
+    private
+
+    def symbolize_keys(object)
+      prepare_object(object) do |key|
+        key.respond_to?(:to_sym) ? key.to_sym : key
+      end
+    end
+
+    def stringify_keys(object)
+      prepare_object(object) do |key|
+        key.respond_to?(:to_s) ? key.to_s : key
+      end
+    end
+
+    def prepare_object(object, &key_modifier)
+      return object unless block_given?
+      case object
+      when Array
+        object.map do |value|
+          prepare_object(value, &key_modifier)
+        end
+      when Hash
+        object.inject({}) do |result, (key, value)|
+          new_key   = key_modifier.call(key)
+          new_value = prepare_object(value, &key_modifier)
+          result.merge! new_key => new_value
+        end
+      when String, Numeric, true, false, nil
+        object
+      else
+        if object.respond_to?(:to_json)
+          object
+        elsif object.respond_to?(:to_s)
+          object.to_s
+        else
+          object
+        end
+      end
+    end
+  end
+end

data/lib/multi_json/options.rb

@@ -0,0 +1,39 @@
+module MultiJson
+  module Options
+    attr_writer :load_options, :dump_options
+
+    def load_options(*args)
+      get_options :load_options, *args
+    end
+
+    def dump_options(*args)
+      get_options :dump_options, *args
+    end
+
+    def default_load_options
+      @default_load_options ||= {}
+    end
+
+    def default_dump_options
+      @default_dump_options ||= {}
+    end
+
+    private
+
+    def get_options(ivar, *args)
+      defaults = send("default_#{ivar}")
+
+      return defaults unless instance_variable_defined?("@#{ivar}")
+
+      value = instance_variable_get("@#{ivar}")
+
+      if value.respond_to?(:call) and value.arity
+        value.arity == 0 ? value[] : value[*args]
+      elsif Hash === value or value.respond_to?(:to_hash)
+        value.to_hash
+      else
+        defaults
+      end
+    end
+  end
+end

data/lib/multi_json/version.rb

@@ -1,3 +1,3 @@
 module MultiJson
-  VERSION = "1.6.1" unless defined?(MultiJson::VERSION)
+  VERSION = '1.7.0' unless defined?(MultiJson::VERSION)
 end

data/spec/adapter_shared_example.rb

@@ -10,7 +10,38 @@ shared_examples_for 'an adapter' do |adapter|
     end
   end
 
+  it_behaves_like 'has options', lambda{ MultiJson.adapter }
+
+  it 'does not modify argument hashes' do
+    options = { :symbolize_keys => true, :pretty => false, :adapter => :json_gem }
+    expect{MultiJson.load('{}', options)}.to_not change{options}
+    expect{MultiJson.dump([42], options)}.to_not change{options}
+  end
+
   describe '.dump' do
+    describe '#dump_options' do
+      before{ MultiJson.dump_options = MultiJson.adapter.dump_options = {} }
+
+      after do
+        MultiJson.adapter.instance.should_receive(:dump).with(1, :foo=>'bar', :fizz=>'buzz')
+        MultiJson.dump(1, :fizz => 'buzz')
+        MultiJson.dump_options = MultiJson.adapter.dump_options = nil
+      end
+
+      it 'respects global dump options' do
+        MultiJson.dump_options = {:foo => 'bar'}
+      end
+
+      it 'respects per-adapter dump options' do
+        MultiJson.adapter.dump_options = {:foo => 'bar'}
+      end
+
+      it 'adapter-specific are overridden by global options' do
+        MultiJson.adapter.dump_options = {:foo => 'foo'}
+        MultiJson.dump_options = {:foo => 'bar'}
+      end
+    end
+
     it 'writes decodable JSON' do
       [
         {'abc' => 'def'},
@@ -75,7 +106,7 @@ shared_examples_for 'an adapter' do |adapter|
 
     # This behavior is currently not supported by gson.rb
     # See discussion at https://github.com/intridea/multi_json/pull/71
-    unless adapter == 'gson'
+    unless %w(gson jrjackson).include?(adapter)
       it 'dumps custom objects that implement to_json' do
         klass = Class.new do
           def to_json(*)
@@ -96,6 +127,47 @@ shared_examples_for 'an adapter' do |adapter|
   end
 
   describe '.load' do
+    describe '#load_options' do
+      before{ MultiJson.load_options = MultiJson.adapter.load_options = {} }
+
+      after do
+        MultiJson.adapter.instance.should_receive(:load).with('1', :foo => 'bar', :fizz => 'buzz')
+        MultiJson.load('1', :fizz => 'buzz')
+        MultiJson.load_options = MultiJson.adapter.load_options = nil
+      end
+
+      it 'respects global load options' do
+        MultiJson.load_options = {:foo => 'bar'}
+      end
+
+      it 'respects per-adapter load options' do
+        MultiJson.adapter.load_options = {:foo => 'bar'}
+      end
+
+      it 'adapter-specific are overridden by global options' do
+        MultiJson.adapter.load_options = {:foo => 'foo'}
+        MultiJson.load_options = {:foo => 'bar'}
+      end
+    end
+
+    it 'does not modify input' do
+      input = %Q{\n\n  {"foo":"bar"} \n\n\t}
+      expect{
+        MultiJson.load(input)
+      }.to_not change{ input }
+    end
+
+    it 'does not modify input encoding' do
+      pending 'only in 1.9' unless RUBY_VERSION > '1.9'
+
+      input = '[123]'
+      input.force_encoding('iso-8859-1')
+
+      expect{
+        MultiJson.load(input)
+      }.to_not change{ input.encoding }
+    end
+
     it 'properly loads valid JSON' do
       expect(MultiJson.load('{"abc":"def"}')).to eq({'abc' => 'def'})
     end

data/spec/has_options.rb

@@ -0,0 +1,74 @@
+shared_examples_for 'has options' do |object|
+
+  if object.respond_to?(:call)
+    subject{ object.call }
+  else
+    subject{ object }
+  end
+
+  %w(dump_options load_options).each do |getter|
+
+    let(:getter){ getter }
+    let(:default_getter){ "default_#{getter}" }
+    let(:setter){ "#{getter}=" }
+    let(:defaults){ subject.send(default_getter) }
+    let(:ivar){ "@#{getter}" }
+
+    describe getter.tr('_', ' ') do
+      before{ set nil }
+      after{ set nil }
+
+      def get(*args)
+        subject.send(getter, *args)
+      end
+
+      def set(value)
+        subject.send(setter, value)
+      end
+
+      it 'returns default options if not set' do
+        expect(get).to eq(defaults)
+      end
+
+      it 'allows hashes' do
+        set :foo => 'bar'
+        expect(get).to eq(:foo => 'bar')
+      end
+
+      it 'allows objects that implement #to_hash' do
+        value = Class.new do
+          def to_hash
+            {:foo=>'bar'}
+          end
+        end.new
+
+        set value
+        expect(get).to eq(:foo => 'bar')
+      end
+
+      it 'evaluates lambda returning options (with args)' do
+        set lambda{ |a1, a2| { a1 => a2 }}
+        expect(get('1', '2')).to eq('1' => '2')
+      end
+
+      it 'evaluates lambda returning options (with no args)' do
+        set lambda{{:foo => 'bar'}}
+        expect(get).to eq(:foo => 'bar')
+      end
+
+      it 'returns empty hash in all other cases' do
+        set true
+        expect(get).to eq(defaults)
+
+        set false
+        expect(get).to eq(defaults)
+
+        set 10
+        expect(get).to eq(defaults)
+
+        set nil
+        expect(get).to eq(defaults)
+      end
+    end
+  end
+end

data/spec/helper.rb

@@ -1,9 +1,11 @@
-if !ENV['CI'] && defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter 'vendor'
-  end
-end
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start
 
 require 'multi_json'
 require 'rspec'
@@ -14,32 +16,17 @@ RSpec.configure do |config|
   end
 end
 
+def silence_warnings
+  old_verbose, $VERBOSE = $VERBOSE, nil
+  yield
+ensure
+  $VERBOSE = old_verbose
+end
+
 def macruby?
   defined?(RUBY_ENGINE) && RUBY_ENGINE == 'macruby'
 end
 
 def jruby?
   defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-end
-
-class MockDecoder
-  def self.load(string, options={})
-    {'abc' => 'def'}
-  end
-
-  def self.dump(string)
-    '{"abc":"def"}'
-  end
-end
-
-module MockModuleDecoder
-  extend self
-
-  def load(string, options={})
-    {'abc' => 'def'}
-  end
-
-  def dump(string)
-    '{"abc":"def"}'
-  end
-end
+end

data/spec/json_common_shared_example.rb

@@ -1,17 +1,13 @@
 shared_examples_for 'JSON-like adapter' do |adapter|
-  before do
-    begin
-      MultiJson.use adapter
-    rescue LoadError
-      pending "Adapter #{adapter} couldn't be loaded (not installed?)"
-    end
-  end
+  before{ MultiJson.use adapter }
 
   describe '.dump' do
+    before{ MultiJson.dump_options = MultiJson.adapter.dump_options = nil }
+
     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).and_return('["foo"]')
+        object.should_receive(:to_json).with(JSON::PRETTY_STATE_PROTOTYPE.to_h)
         MultiJson.dump(object, :pretty => true)
       end
     end
@@ -19,18 +15,16 @@ shared_examples_for 'JSON-like adapter' do |adapter|
     describe 'with :indent option' do
       it 'passes it on dump' do
         object = 'foo'
-        object.should_receive(:to_json).with(:indent => "\t").and_return('["foo"]')
+        object.should_receive(:to_json).with(:indent => "\t")
         MultiJson.dump(object, :indent => "\t")
       end
     end
   end
 
   describe '.load' do
-    describe 'with :quirks_mode option' do
-      it 'passes it on load' do
-        ::JSON.should_receive(:parse).with('["foo"]', {:quirks_mode => true, :create_additions => false}).and_return(['foo'])
-        MultiJson.load('"foo"', :quirks_mode => true)
-      end
+    it 'passes :quirks_mode option' do
+      ::JSON.should_receive(:parse).with('[123]', {:quirks_mode => false, :create_additions => false})
+      MultiJson.load('[123]', :quirks_mode => false)
     end
   end
 end

data/spec/multi_json_spec.rb

@@ -1,6 +1,7 @@
 require 'helper'
 require 'adapter_shared_example'
 require 'json_common_shared_example'
+require 'has_options'
 require 'stringio'
 
 describe 'MultiJson' do
@@ -34,8 +35,9 @@ describe 'MultiJson' do
       end
 
       it 'defaults to ok_json if no other json implementions are available' do
-        Kernel.stub(:warn)
-        expect(MultiJson.default_adapter).to eq :ok_json
+        silence_warnings do
+          expect(MultiJson.default_adapter).to eq :ok_json
+        end
       end
 
       it 'prints a warning' do
@@ -48,47 +50,50 @@ describe 'MultiJson' 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'
+        expect(MultiJson.adapter).to eq MultiJson::Adapters::Oj
       else
-        require 'json'
-        expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::JsonGem'
+        expect(MultiJson.adapter).to eq MultiJson::Adapters::JsonGem
       end
     end
 
     it 'looks for adapter even if @adapter variable is nil' do
       MultiJson.send(:instance_variable_set, :@adapter, nil)
       MultiJson.should_receive(:default_adapter).and_return(:ok_json)
-      expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::OkJson'
+      expect(MultiJson.adapter).to eq MultiJson::Adapters::OkJson
     end
 
     it 'is settable via a symbol' do
       MultiJson.use :json_gem
-      expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::JsonGem'
+      expect(MultiJson.adapter).to eq MultiJson::Adapters::JsonGem
     end
 
     it 'is settable via a class' do
-      MultiJson.use MockDecoder
-      expect(MultiJson.adapter.name).to eq 'MockDecoder'
+      adapter = Class.new
+      MultiJson.use adapter
+      expect(MultiJson.adapter).to eq adapter
     end
 
     it 'is settable via a module' do
-      MultiJson.use MockModuleDecoder
-      expect(MultiJson.adapter.name).to eq 'MockModuleDecoder'
+      adapter = Module.new
+      MultiJson.use adapter
+      expect(MultiJson.adapter).to eq adapter
+    end
+
+    it 'throws ArgumentError on bad input' do
+      expect{ MultiJson.use 'bad adapter' }.to raise_error(ArgumentError)
     end
 
     context 'using one-shot parser' do
       before 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')
+        MultiJson::Adapters::JsonPure.should_receive(:dump).once.and_return('dump_something')
+        MultiJson::Adapters::JsonPure.should_receive(:load).once.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'
+        expect(MultiJson.adapter).to eq MultiJson::Adapters::JsonGem
       end
     end
   end
@@ -97,11 +102,11 @@ describe 'MultiJson' do
     MultiJson.use :ok_json
     MultiJson.with_adapter(:json_pure) do
       MultiJson.with_engine(:json_gem) do
-        expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::JsonGem'
+        expect(MultiJson.adapter).to eq MultiJson::Adapters::JsonGem
       end
-      expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::JsonPure'
+      expect(MultiJson.adapter).to eq MultiJson::Adapters::JsonPure
     end
-    expect(MultiJson.adapter.name).to eq 'MultiJson::Adapters::OkJson'
+    expect(MultiJson.adapter).to eq MultiJson::Adapters::OkJson
   end
 
   it 'JSON gem does not create symbols on parse' do
@@ -126,18 +131,28 @@ describe 'MultiJson' do
     end
   end
 
-  it 'has default_options setter' do
-    MultiJson.use MockDecoder
-    MockDecoder.should_receive(:dump).with('123', :foo => 'lol', :bar => 'bar', :fizz => 'buzz')
-    MultiJson.default_options = { :foo => 'foo', :bar => 'bar' }
-    MultiJson.dump('123', :fizz => 'buzz', :foo => 'lol')
-    MultiJson.default_options = {}
+  describe 'default options' do
+    after(:all){ MultiJson.load_options = MultiJson.dump_options = nil }
+
+    it 'is deprecated' do
+      Kernel.should_receive(:warn).with(/deprecated/i)
+      silence_warnings{ MultiJson.default_options = {:foo => 'bar'} }
+    end
+
+    it 'sets both load and dump options' do
+      MultiJson.should_receive(:dump_options=).with(:foo => 'bar')
+      MultiJson.should_receive(:load_options=).with(:foo => 'bar')
+      silence_warnings{ MultiJson.default_options = {:foo => 'bar'} }
+    end
   end
 
-  %w(gson json_gem json_pure nsjsonserialization oj ok_json yajl).each do |adapter|
-    next if adapter == 'gson' && !jruby?
-    next if adapter == 'nsjsonserialization' && !macruby?
-    next if jruby? && (adapter == 'oj' || adapter == 'yajl')
+  it_behaves_like 'has options', MultiJson
+
+  %w(gson jrjackson json_gem json_pure nsjsonserialization oj ok_json yajl).each do |adapter|
+    next if !jruby? && %w(gson jrjackson).include?(adapter)
+    next if !macruby? && adapter == 'nsjsonserialization'
+    next if jruby? && %w(oj yajl).include?(adapter)
+
     context adapter do
       it_behaves_like 'an adapter', adapter
     end
@@ -148,4 +163,4 @@ describe 'MultiJson' do
       it_behaves_like 'JSON-like adapter', adapter
     end
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: multi_json
 version: !ruby/object:Gem::Version
-  version: 1.6.1
+  version: 1.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -39,7 +39,7 @@ cert_chain:
   U0xxV3ZRUnNCbHlwSGZoczZKSnVMbHlaUEdoVTNSL3YKU2YzbFZLcEJDV2dS
   cEdUdnk0NVhWcEIrNTl5MzNQSm1FdVExUFRFT1l2UXlhbzlVS01BQWFBTi83
   cVdRdGpsMApobHc9Ci0tLS0tRU5EIENFUlRJRklDQVRFLS0tLS0K
-date: 2013-02-14 00:00:00.000000000 Z
+date: 2013-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -79,10 +79,13 @@ files:
 - .rspec
 - .travis.yml
 - spec/adapter_shared_example.rb
+- spec/has_options.rb
 - spec/helper.rb
 - spec/json_common_shared_example.rb
 - spec/multi_json_spec.rb
+- lib/multi_json/adapter.rb
 - lib/multi_json/adapters/gson.rb
+- lib/multi_json/adapters/jrjackson.rb
 - lib/multi_json/adapters/json_common.rb
 - lib/multi_json/adapters/json_gem.rb
 - lib/multi_json/adapters/json_pure.rb
@@ -90,6 +93,8 @@ files:
 - lib/multi_json/adapters/oj.rb
 - lib/multi_json/adapters/ok_json.rb
 - lib/multi_json/adapters/yajl.rb
+- lib/multi_json/convertible_hash_keys.rb
+- lib/multi_json/options.rb
 - lib/multi_json/vendor/okjson.rb
 - lib/multi_json/version.rb
 - lib/multi_json.rb
@@ -114,12 +119,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: A gem to provide swappable JSON backends.
 test_files:
 - spec/adapter_shared_example.rb
+- spec/has_options.rb
 - spec/helper.rb
 - spec/json_common_shared_example.rb
 - spec/multi_json_spec.rb