multi_json 1.2.0 → 1.3.0

data/README.md

@@ -88,12 +88,10 @@ implementations:
 * Ruby 1.9.3
 * [JRuby][]
 * [Rubinius][]
-* [Ruby Enterprise Edition][ree]
 * [MacRuby][] (not tested on Travis CI)
 
 [jruby]: http://www.jruby.org/
 [rubinius]: http://rubini.us/
-[ree]: http://www.rubyenterpriseedition.com/
 [macruby]: http://www.macruby.org/
 
 If something doesn't work on one of these interpreters, it should be considered

data/lib/multi_json.rb

@@ -10,14 +10,7 @@ module MultiJson
 
   module_function
 
-  @engine = nil
-
-  # Get the current engine class.
-  def engine
-    return @engine if @engine
-    self.engine = self.default_engine
-    @engine
-  end
+  @adapter = nil
 
   REQUIREMENT_MAP = [
     ["oj", :oj],
@@ -26,65 +19,95 @@ module MultiJson
     ["json/pure", :json_pure]
   ]
 
-  DEFAULT_ENGINE_WARNING = 'Warning: multi_json is using default ok_json engine. Suggested action: require and load an appropriate JSON library.'
-
-  # The default engine based on what you currently
+  # The default adapter based on what you currently
   # have loaded and installed. First checks to see
-  # if any engines are already loaded, then checks
+  # if any adapters are already loaded, then checks
   # to see which are installed if none are loaded.
-  def default_engine
+  def default_adapter
     return :oj if defined?(::Oj)
     return :yajl if defined?(::Yajl)
     return :json_gem if defined?(::JSON)
 
-    REQUIREMENT_MAP.each do |(library, engine)|
+    REQUIREMENT_MAP.each do |(library, adapter)|
       begin
         require library
-        return engine
+        return adapter
       rescue LoadError
         next
       end
     end
 
-    Kernel.warn DEFAULT_ENGINE_WARNING
+    Kernel.warn "[WARNING] MultiJson is using the default adapter (ok_json). We recommend loading a different JSON library to improve performance."
     :ok_json
   end
 
+  # TODO: Remove for 2.0 release (but no sooner)
+  def engine
+    Kernel.warn "#{Kernel.caller.first}: [DEPRECATION] MultiJson.engine is deprecated and will be removed in the next major version. Use MultiJson.adapter instead."
+    self.adapter
+  end
+
+  # Get the current adapter class.
+  def adapter
+    return @adapter if @adapter
+    self.use self.default_adapter
+    @adapter
+  end
+
+  # TODO: Remove for 2.0 release (but no sooner)
+  def adapter=(new_adapter)
+    Kernel.warn "#{Kernel.caller.first}: [DEPRECATION] MultiJson.adapter= is deprecated and will be removed in the next major version. Use MultiJson.use instead."
+    self.use(new_adapter)
+  end
+
   # Set the JSON parser utilizing a symbol, string, or class.
   # Supported by default are:
   #
+  # * <tt>:oj</tt>
   # * <tt>:json_gem</tt>
   # * <tt>:json_pure</tt>
   # * <tt>:ok_json</tt>
   # * <tt>:yajl</tt>
   # * <tt>:nsjsonserialization</tt> (MacRuby only)
-  def engine=(new_engine)
-    case new_engine
+  def use(new_adapter)
+    case new_adapter
     when String, Symbol
-      require "multi_json/engines/#{new_engine}"
-      @engine = MultiJson::Engines.const_get("#{new_engine.to_s.split('_').map{|s| s.capitalize}.join('')}")
+      require "multi_json/adapters/#{new_adapter}"
+      @adapter = MultiJson::Adapters.const_get("#{new_adapter.to_s.split('_').map{|s| s.capitalize}.join('')}")
     when NilClass
-      @engine = nil
+      @adapter = nil
     when Class
-      @engine = new_engine
+      @adapter = new_adapter
     else
-      raise "Did not recognize your engine specification. Please specify either a symbol or a class."
+      raise "Did not recognize your adapter specification. Please specify either a symbol or a class."
     end
   end
 
+  # TODO: Remove for 2.0 release (but no sooner)
+  def decode(string, options={})
+    Kernel.warn "#{Kernel.caller.first}: [DEPRECATION] MultiJson.decode is deprecated and will be removed in the next major version. Use MultiJson.load instead."
+    self.load(string, options)
+  end
+
   # Decode a JSON string into Ruby.
   #
   # <b>Options</b>
   #
   # <tt>:symbolize_keys</tt> :: If true, will use symbols instead of strings for the keys.
-  def decode(string, options = {})
-    engine.decode(string, options)
-  rescue engine::ParseError => exception
+  def load(string, options={})
+    adapter.load(string, options)
+  rescue adapter::ParseError => exception
     raise DecodeError.new(exception.message, exception.backtrace, string)
   end
 
+  # TODO: Remove for 2.0 release (but no sooner)
+  def encode(object, options={})
+    Kernel.warn "#{Kernel.caller.first}: [DEPRECATION] MultiJson.encode is deprecated and will be removed in the next major version. Use MultiJson.dump instead."
+    self.dump(object, options)
+  end
+
   # Encodes a Ruby object as JSON.
-  def encode(object, options = {})
-    engine.encode(object, options)
+  def dump(object, options={})
+    adapter.dump(object, options)
   end
 end

data/lib/multi_json/{engines → adapters}/json_common.rb

@@ -1,15 +1,13 @@
 module MultiJson
-  module Engines
+  module Adapters
     module JsonCommon
 
-      def decode(string, options={})
-        opts = {}
-        opts[:symbolize_names] = options[:symbolize_keys]
+      def load(string, options={})
         string = string.read if string.respond_to?(:read)
-        ::JSON.parse(string, opts)
+        ::JSON.parse(string, :symbolize_names => options[:symbolize_keys])
       end
 
-      def encode(object, options={})
+      def dump(object, options={})
         object.to_json(process_options(options))
       end
 
@@ -19,7 +17,7 @@ module MultiJson
         return options if options.empty?
         opts = {}
         opts.merge!(JSON::PRETTY_STATE_PROTOTYPE.to_h) if options.delete(:pretty)
-        opts.merge! options
+        opts.merge!(options)
       end
 
     end

data/lib/multi_json/{engines → adapters}/json_gem.rb

@@ -1,9 +1,9 @@
 require 'json' unless defined?(::JSON)
-require 'multi_json/engines/json_common'
+require 'multi_json/adapters/json_common'
 
 module MultiJson
-  module Engines
-    # Use the JSON gem to encode/decode.
+  module Adapters
+    # Use the JSON gem to dump/load.
     class JsonGem
       ParseError = ::JSON::ParserError
       extend JsonCommon

data/lib/multi_json/{engines → adapters}/json_pure.rb

@@ -1,9 +1,9 @@
 require 'json/pure' unless defined?(::JSON)
-require 'multi_json/engines/json_common'
+require 'multi_json/adapters/json_common'
 
 module MultiJson
-  module Engines
-    # Use JSON pure to encode/decode.
+  module Adapters
+    # Use JSON pure to dump/load.
     class JsonPure
       ParseError = ::JSON::ParserError
       extend JsonCommon

data/lib/multi_json/{engines → adapters}/nsjsonserialization.rb

@@ -1,12 +1,12 @@
 framework 'Foundation'
-require 'multi_json/engines/ok_json'
+require 'multi_json/adapters/ok_json'
 
 module MultiJson
-  module Engines
-    class Nsjsonserialization < MultiJson::Engines::OkJson
+  module Adapters
+    class Nsjsonserialization < MultiJson::Adapters::OkJson
       ParseError = ::MultiJson::OkJson::Error
 
-      def self.decode(string, options = {})
+      def self.load(string, options={})
         string = string.read if string.respond_to?(:read)
         data = string.dataUsingEncoding(NSUTF8StringEncoding)
         object = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingMutableContainers | NSJSONReadingMutableLeaves, error: nil)
@@ -14,11 +14,11 @@ module MultiJson
           object = symbolize_keys(object) if options[:symbolize_keys]
           object
         else
-          super(string, options = {})
+          super(string, options={})
         end
       end
 
-      def self.encode(object, options = {})
+      def self.dump(object, options={})
         pretty = options[:pretty] ? NSJSONWritingPrettyPrinted : 0
         object = object.as_json if object.respond_to?(:as_json)
         if NSJSONSerialization.isValidJSONObject(object)

data/lib/multi_json/adapters/oj.rb

@@ -0,0 +1,20 @@
+require 'oj' unless defined?(::Oj)
+
+module MultiJson
+  module Adapters
+    # Use the Oj library to dump/load.
+    class Oj
+      ParseError = SyntaxError
+
+      ::Oj.default_options = {:mode => :compat}
+
+      def self.load(string, options={}) #:nodoc:
+        ::Oj.load(string, :symbol_keys => options[:symbolize_keys])
+      end
+
+      def self.dump(object, options={}) #:nodoc:
+        ::Oj.dump(object, options)
+      end
+    end
+  end
+end

data/lib/multi_json/{engines → adapters}/ok_json.rb

@@ -1,17 +1,17 @@
-require 'multi_json/vendor/ok_json'
+require 'multi_json/vendor/okjson'
 
 module MultiJson
-  module Engines
+  module Adapters
     class OkJson
       ParseError = ::MultiJson::OkJson::Error
 
-      def self.decode(string, options = {}) #:nodoc:
+      def self.load(string, options={}) #:nodoc:
         string = string.read if string.respond_to?(:read)
         result = ::MultiJson::OkJson.decode(string)
         options[:symbolize_keys] ? symbolize_keys(result) : result
       end
 
-      def self.encode(object, options = {}) #:nodoc:
+      def self.dump(object, options={}) #:nodoc:
         ::MultiJson::OkJson.valenc(stringify_keys(object))
       end
 

data/lib/multi_json/{engines → adapters}/yajl.rb

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

data/lib/multi_json/vendor/{ok_json.rb → okjson.rb}

@@ -1,4 +1,6 @@
-# Copyright 2011 Keith Rarick
+# encoding: UTF-8
+#
+# Copyright 2011, 2012 Keith Rarick
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -166,7 +168,7 @@ module MultiJson
     end
 
 
-    # Sans s and returns a list of json tokens,
+    # Scans s and returns a list of json tokens,
     # excluding white space (as defined in RFC 4627).
     def lex(s)
       ts = []
@@ -186,7 +188,7 @@ module MultiJson
 
     # Scans the first token in s and
     # returns a 3-element list, or nil
-    # if no such token exists.
+    # if s does not begin with a valid token.
     #
     # The first list element is one of
     # '{', '}', ':', ',', '[', ']',
@@ -218,9 +220,9 @@ module MultiJson
     end
 
 
-    def nulltok(s);  s[0,4] == 'null'  && [:val, 'null',  nil]   end
-    def truetok(s);  s[0,4] == 'true'  && [:val, 'true',  true]  end
-    def falsetok(s); s[0,5] == 'false' && [:val, 'false', false] end
+    def nulltok(s);  s[0,4] == 'null'  ? [:val, 'null',  nil]   : [] end
+    def truetok(s);  s[0,4] == 'true'  ? [:val, 'true',  true]  : [] end
+    def falsetok(s); s[0,5] == 'false' ? [:val, 'false', false] : [] end
 
 
     def numtok(s)
@@ -233,6 +235,8 @@ module MultiJson
         else
           [:val, m[0], Integer(m[0])]
         end
+      else
+        []
       end
     end
 
@@ -261,6 +265,12 @@ module MultiJson
     def unquote(q)
       q = q[1...-1]
       a = q.dup # allocate a big enough string
+      rubydoesenc = false
+      # In ruby >= 1.9, a[w] is a codepoint, not a byte.
+      if a.class.method_defined?(:force_encoding)
+        a.force_encoding('UTF-8')
+        rubydoesenc = true
+      end
       r, w = 0, 0
       while r < q.length
         c = q[r]
@@ -298,7 +308,12 @@ module MultiJson
                 end
               end
             end
-            w += ucharenc(a, w, uchar)
+            if rubydoesenc
+              a[w] = '' << uchar
+              w += 1
+            else
+              w += ucharenc(a, w, uchar)
+            end
           else
             raise Error, "invalid escape char #{q[r]} in \"#{q}\""
           end
@@ -308,6 +323,8 @@ module MultiJson
           # Copy anything else byte-for-byte.
           # Valid UTF-8 will remain valid UTF-8.
           # Invalid UTF-8 will remain invalid UTF-8.
+          # In ruby >= 1.9, c is a codepoint, not a byte,
+          # in which case this is still what we want.
           a[w] = c
           r += 1
           w += 1
@@ -360,15 +377,6 @@ module MultiJson
     end
 
 
-    def unsubst(u)
-      if u < Usurrself || u > Umax || surrogate?(u)
-        return Ucharerr, Ucharerr
-      end
-      u -= Usurrself
-      [Usurr1 + ((u>>10)&0x3ff), Usurr2 + (u&0x3ff)]
-    end
-
-
     def surrogate?(u)
       Usurr1 <= u && u < Usurr3
     end
@@ -446,6 +454,10 @@ module MultiJson
       t = StringIO.new
       t.putc(?")
       r = 0
+
+      # In ruby >= 1.9, s[r] is a codepoint, not a byte.
+      rubydoesenc = s.class.method_defined?(:encoding)
+
       while r < s.length
         case s[r]
         when ?"  then t.print('\\"')
@@ -458,23 +470,18 @@ module MultiJson
         else
           c = s[r]
           case true
+          when rubydoesenc
+            begin
+              c.ord # will raise an error if c is invalid UTF-8
+              t.write(c)
+            rescue
+              t.write(Ustrerr)
+            end
           when Spc <= c && c <= ?~
             t.putc(c)
-          when true
-            u, size = uchardec(s, r)
-            r += size - 1 # we add one more at the bottom of the loop
-            if u < 0x10000
-              t.print('\\u')
-              hexenc4(t, u)
-            else
-              u1, u2 = unsubst(u)
-              t.print('\\u')
-              hexenc4(t, u1)
-              t.print('\\u')
-              hexenc4(t, u2)
-            end
           else
-            # invalid byte; skip it
+            n = ucharcopy(t, s, r) # ensure valid UTF-8 output
+            r += n - 1 # r is incremented below
           end
         end
         r += 1
@@ -484,76 +491,85 @@ module MultiJson
     end
 
 
-    def hexenc4(t, u)
-      t.putc(Hex[(u>>12)&0xf])
-      t.putc(Hex[(u>>8)&0xf])
-      t.putc(Hex[(u>>4)&0xf])
-      t.putc(Hex[u&0xf])
-    end
-
-
     def numenc(x)
-      if x.nan? || x.infinite?
-        return 'null'
-      end rescue nil
+      if ((x.nan? || x.infinite?) rescue false)
+        raise Error, "Numeric cannot be represented: #{x}"
+      end
       "#{x}"
     end
 
 
-    # Decodes unicode character u from UTF-8
-    # bytes in string s at position i.
-    # Returns u and the number of bytes read.
-    def uchardec(s, i)
+    # Copies the valid UTF-8 bytes of a single character
+    # from string s at position i to I/O object t, and
+    # returns the number of bytes copied.
+    # If no valid UTF-8 char exists at position i,
+    # ucharcopy writes Ustrerr and returns 1.
+    def ucharcopy(t, s, i)
       n = s.length - i
-      return [Ucharerr, 1] if n < 1
+      raise Utf8Error if n < 1
 
       c0 = s[i].ord
 
       # 1-byte, 7-bit sequence?
       if c0 < Utagx
-        return [c0, 1]
+        t.putc(c0)
+        return 1
       end
 
-      # unexpected continuation byte?
-      return [Ucharerr, 1] if c0 < Utag2
+      raise Utf8Error if c0 < Utag2 # unexpected continuation byte?
 
-      # need continuation byte
-      return [Ucharerr, 1] if n < 2
+      raise Utf8Error if n < 2 # need continuation byte
       c1 = s[i+1].ord
-      return [Ucharerr, 1] if c1 < Utagx || Utag2 <= c1
+      raise Utf8Error if c1 < Utagx || Utag2 <= c1
 
       # 2-byte, 11-bit sequence?
       if c0 < Utag3
-        u = (c0&Umask2)<<6 | (c1&Umaskx)
-        return [Ucharerr, 1] if u <= Uchar1max
-        return [u, 2]
+        raise Utf8Error if ((c0&Umask2)<<6 | (c1&Umaskx)) <= Uchar1max
+        t.putc(c0)
+        t.putc(c1)
+        return 2
       end
 
       # need second continuation byte
-      return [Ucharerr, 1] if n < 3
+      raise Utf8Error if n < 3
+
       c2 = s[i+2].ord
-      return [Ucharerr, 1] if c2 < Utagx || Utag2 <= c2
+      raise Utf8Error if c2 < Utagx || Utag2 <= c2
 
       # 3-byte, 16-bit sequence?
       if c0 < Utag4
         u = (c0&Umask3)<<12 | (c1&Umaskx)<<6 | (c2&Umaskx)
-        return [Ucharerr, 1] if u <= Uchar2max
-        return [u, 3]
+        raise Utf8Error if u <= Uchar2max
+        t.putc(c0)
+        t.putc(c1)
+        t.putc(c2)
+        return 3
       end
 
       # need third continuation byte
-      return [Ucharerr, 1] if n < 4
+      raise Utf8Error if n < 4
       c3 = s[i+3].ord
-      return [Ucharerr, 1] if c3 < Utagx || Utag2 <= c3
+      raise Utf8Error if c3 < Utagx || Utag2 <= c3
 
       # 4-byte, 21-bit sequence?
       if c0 < Utag5
         u = (c0&Umask4)<<18 | (c1&Umaskx)<<12 | (c2&Umaskx)<<6 | (c3&Umaskx)
-        return [Ucharerr, 1] if u <= Uchar3max
-        return [u, 4]
+        raise Utf8Error if u <= Uchar3max
+        t.putc(c0)
+        t.putc(c1)
+        t.putc(c2)
+        t.putc(c3)
+        return 4
       end
 
-      return [Ucharerr, 1]
+      raise Utf8Error
+    rescue Utf8Error
+      t.write(Ustrerr)
+      return 1
+    end
+
+
+    class Utf8Error < ::StandardError
     end
 
 
@@ -574,14 +590,13 @@ module MultiJson
     Uchar2max = (1<<11) - 1
     Uchar3max = (1<<16) - 1
     Ucharerr = 0xFFFD # unicode "replacement char"
+    Ustrerr = "\xef\xbf\xbd" # unicode "replacement char"
     Usurrself = 0x10000
     Usurr1 = 0xd800
     Usurr2 = 0xdc00
     Usurr3 = 0xe000
-    Umax = 0x10ffff
 
     Spc = ' '[0]
     Unesc = {?b=>?\b, ?f=>?\f, ?n=>?\n, ?r=>?\r, ?t=>?\t}
-    Hex = '0123456789abcdef'
   end
 end

data/lib/multi_json/version.rb

@@ -1,3 +1,3 @@
 module MultiJson
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

data/multi_json.gemspec

@@ -13,6 +13,23 @@ Gem::Specification.new do |gem|
   gem.files = Dir['LICENSE.md', 'README.md', 'Rakefile', 'multi_json.gemspec', 'Gemfile', '.document', '.rspec', '.travis.yml' ,'spec/**/*', 'lib/**/*']
   gem.homepage = 'http://github.com/intridea/multi_json'
   gem.name = 'multi_json'
+  gem.post_install_message =<<eos
+********************************************************************************
+
+  MultiJson.encode is deprecated and will be removed in the next major version.
+  Use MultiJson.dump instead.
+
+  MultiJson.decode is deprecated and will be removed in the next major version.
+  Use MultiJson.load instead.
+
+  MultiJson.engine is deprecated and will be removed in the next major version.
+  Use MultiJson.adapter instead.
+
+  MultiJson.engine= is deprecated and will be removed in the next major version.
+  Use MultiJson.use instead.
+
+********************************************************************************
+eos
   gem.rdoc_options = ["--charset=UTF-8"]
   gem.require_paths = ['lib']
   gem.required_rubygems_version = Gem::Requirement.new(">= 1.3.6")

data/spec/{engine_shared_example.rb → adapter_shared_example.rb}

@@ -1,24 +1,24 @@
-shared_examples_for "an engine" do |engine|
+shared_examples_for "an adapter" do |adapter|
 
   before do
     begin
-      MultiJson.engine = engine
+      MultiJson.use adapter
     rescue LoadError
-      pending "Engine #{engine} couldn't be loaded (not installed?)"
+      pending "Adapter #{adapter} couldn't be loaded (not installed?)"
     end
   end
 
-  describe '.encode' do
+  describe '.dump' do
     it 'writes decodable JSON' do
       [
         {'abc' => 'def'},
         [1, 2, 3, "4"],
       ].each do |example|
-        MultiJson.decode(MultiJson.encode(example)).should == example
+        MultiJson.load(MultiJson.dump(example)).should == example
       end
     end
 
-    it 'encodes symbol keys as strings' do
+    it 'dumps symbol keys as strings' do
       [
         [
           {:foo => {:bar => 'baz'}},
@@ -33,64 +33,64 @@ shared_examples_for "an engine" do |engine|
           {'foo' => [{'bar' => 'baz'}]},
         ]
       ].each do |example, expected|
-        encoded_json = MultiJson.encode(example)
-        MultiJson.decode(encoded_json).should == expected
+        dumped_json = MultiJson.dump(example)
+        MultiJson.load(dumped_json).should == expected
       end
     end
 
-    it 'encodes rootless JSON' do
-      MultiJson.encode("random rootless string").should == "\"random rootless string\""
-      MultiJson.encode(123).should == "123"
+    it 'dumps rootless JSON' do
+      MultiJson.dump("random rootless string").should == "\"random rootless string\""
+      MultiJson.dump(123).should == "123"
     end
 
-    it 'passes options to the engine' do
-      MultiJson.engine.should_receive(:encode).with('foo', {:bar => :baz})
-      MultiJson.encode('foo', :bar => :baz)
+    it 'passes options to the adapter' do
+      MultiJson.adapter.should_receive(:dump).with('foo', {:bar => :baz})
+      MultiJson.dump('foo', :bar => :baz)
     end
 
-    if engine == 'json_gem' || engine == 'json_pure'
+    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.encode(object,:pretty => true)
+          MultiJson.dump(object,:pretty => true)
         end
       end
     end
 
-    it "encodes custom objects which implement as_json" do
-      MultiJson.encode(TimeWithZone.new).should == "\"2005-02-01T15:15:10Z\""
+    it 'dumps custom objects which implement as_json' do
+      MultiJson.dump(TimeWithZone.new).should == "\"2005-02-01T15:15:10Z\""
     end
   end
 
-  describe '.decode' do
-    it 'properly decodes valid JSON' do
-      MultiJson.decode('{"abc":"def"}').should == {'abc' => 'def'}
+  describe '.load' do
+    it 'properly loads valid JSON' do
+      MultiJson.load('{"abc":"def"}').should == {'abc' => 'def'}
     end
 
     it 'raises MultiJson::DecodeError on invalid JSON' do
       lambda do
-        MultiJson.decode('{"abc"}')
+        MultiJson.load('{"abc"}')
       end.should raise_error(MultiJson::DecodeError)
     end
 
     it 'raises MultiJson::DecodeError with data on invalid JSON' do
       data = '{invalid}'
       begin
-        MultiJson.decode(data)
+        MultiJson.load(data)
       rescue MultiJson::DecodeError => de
         de.data.should == data
       end
     end
 
     it 'stringifys symbol keys when encoding' do
-      encoded_json = MultiJson.encode(:a => 1, :b => {:c => 2})
-      MultiJson.decode(encoded_json).should == {"a" => 1, "b" => {"c" => 2}}
+      dumped_json = MultiJson.dump(:a => 1, :b => {:c => 2})
+      MultiJson.load(dumped_json).should == {"a" => 1, "b" => {"c" => 2}}
     end
 
-    it "properly decodes valid JSON in StringIOs" do
+    it 'properly loads valid JSON in StringIOs' do
       json = StringIO.new('{"abc":"def"}')
-      MultiJson.decode(json).should == {'abc' => 'def'}
+      MultiJson.load(json).should == {'abc' => 'def'}
     end
 
     it 'allows for symbolization of keys' do
@@ -108,7 +108,7 @@ shared_examples_for "an engine" do |engine|
           {:abc => [{:def => 'hgi'}]},
         ],
       ].each do |example, expected|
-        MultiJson.decode(example, :symbolize_keys => true).should == expected
+        MultiJson.load(example, :symbolize_keys => true).should == expected
       end
     end
   end

data/spec/helper.rb

@@ -14,17 +14,17 @@ require 'multi_json'
 require 'rspec'
 
 class MockDecoder
-  def self.decode(string, options = {})
+  def self.load(string, options={})
     {'abc' => 'def'}
   end
 
-  def self.encode(string)
+  def self.dump(string)
     '{"abc":"def"}'
   end
 end
 
 class TimeWithZone
-  def to_json(options = {})
+  def to_json(options={})
     "\"2005-02-01T15:15:10Z\""
   end
 end

data/spec/multi_json_spec.rb

@@ -1,11 +1,11 @@
 require 'helper'
-require 'engine_shared_example'
+require 'adapter_shared_example'
 require 'stringio'
 
 describe 'MultiJson' do
-  context 'engines' do
+  context 'adapters' do
     before do
-      MultiJson.engine = nil
+      MultiJson.use nil
     end
     context 'when no other json implementations are available' do
       before do
@@ -13,8 +13,8 @@ describe 'MultiJson' do
         @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, engine), index|
-          MultiJson::REQUIREMENT_MAP[index] = ["foo/#{library}", engine]
+        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
@@ -22,8 +22,8 @@ describe 'MultiJson' do
       end
 
       after do
-        @old_map.each_with_index do |(library, engine), index|
-          MultiJson::REQUIREMENT_MAP[index] = [library, engine]
+        @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
@@ -31,42 +31,42 @@ describe 'MultiJson' do
       end
 
       it 'defaults to ok_json if no other json implementions are available' do
-        MultiJson.default_engine.should == :ok_json
+        MultiJson.default_adapter.should == :ok_json
       end
 
       it 'prints a warning' do
         Kernel.should_receive(:warn).with(/warning/i)
-        MultiJson.default_engine
+        MultiJson.default_adapter
       end
     end
 
     it 'defaults to the best available gem' do
       unless jruby?
         require 'oj'
-        MultiJson.engine.name.should == 'MultiJson::Engines::Oj'
+        MultiJson.adapter.name.should == 'MultiJson::Adapters::Oj'
       else
         require 'json'
-        MultiJson.engine.name.should == 'MultiJson::Engines::JsonGem'
+        MultiJson.adapter.name.should == 'MultiJson::Adapters::JsonGem'
       end
     end
 
     it 'is settable via a symbol' do
-      MultiJson.engine = :json_gem
-      MultiJson.engine.name.should == 'MultiJson::Engines::JsonGem'
+      MultiJson.use :json_gem
+      MultiJson.adapter.name.should == 'MultiJson::Adapters::JsonGem'
     end
 
     it 'is settable via a class' do
-      MultiJson.engine = MockDecoder
-      MultiJson.engine.name.should == 'MockDecoder'
+      MultiJson.use MockDecoder
+      MultiJson.adapter.name.should == 'MockDecoder'
     end
   end
 
-  %w(json_gem json_pure nsjsonserialization oj ok_json yajl).each do |engine|
-    next if !macruby? && engine == 'nsjsonserialization'
-    next if jruby? && (engine == 'oj' || engine == 'yajl')
+  %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 engine do
-      it_should_behave_like "an engine", engine
+    context adapter do
+      it_should_behave_like "an adapter", adapter
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: multi_json
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-27 00:00:00.000000000 Z
+date: 2012-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -97,22 +97,28 @@ files:
 - .document
 - .rspec
 - .travis.yml
-- spec/engine_shared_example.rb
+- spec/adapter_shared_example.rb
 - spec/helper.rb
 - spec/multi_json_spec.rb
-- lib/multi_json/engines/json_common.rb
-- lib/multi_json/engines/json_gem.rb
-- lib/multi_json/engines/json_pure.rb
-- lib/multi_json/engines/nsjsonserialization.rb
-- lib/multi_json/engines/oj.rb
-- lib/multi_json/engines/ok_json.rb
-- lib/multi_json/engines/yajl.rb
-- lib/multi_json/vendor/ok_json.rb
+- lib/multi_json/adapters/json_common.rb
+- lib/multi_json/adapters/json_gem.rb
+- lib/multi_json/adapters/json_pure.rb
+- lib/multi_json/adapters/nsjsonserialization.rb
+- lib/multi_json/adapters/oj.rb
+- lib/multi_json/adapters/ok_json.rb
+- lib/multi_json/adapters/yajl.rb
+- lib/multi_json/vendor/okjson.rb
 - lib/multi_json/version.rb
 - lib/multi_json.rb
 homepage: http://github.com/intridea/multi_json
 licenses: []
-post_install_message: 
+post_install_message: ! "********************************************************************************\n\n
+  \ MultiJson.encode is deprecated and will be removed in the next major version.\n
+  \ Use MultiJson.dump instead.\n\n  MultiJson.decode is deprecated and will be removed
+  in the next major version.\n  Use MultiJson.load instead.\n\n  MultiJson.engine
+  is deprecated and will be removed in the next major version.\n  Use MultiJson.adapter
+  instead.\n\n  MultiJson.engine= is deprecated and will be removed in the next major
+  version.\n  Use MultiJson.use instead.\n\n********************************************************************************\n"
 rdoc_options:
 - --charset=UTF-8
 require_paths:
@@ -131,12 +137,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 1.8.22
 signing_key: 
 specification_version: 3
 summary: A gem to provide swappable JSON backends.
 test_files:
-- spec/engine_shared_example.rb
+- spec/adapter_shared_example.rb
 - spec/helper.rb
 - spec/multi_json_spec.rb
 has_rdoc: 

data/lib/multi_json/engines/oj.rb

@@ -1,22 +0,0 @@
-require 'oj' unless defined?(::Oj)
-
-::Oj.default_options = {:mode => :compat}
-
-module MultiJson
-  module Engines
-    # Use the Oj library to encode/decode.
-    class Oj
-      ParseError = SyntaxError
-
-      def self.decode(string, options = {}) #:nodoc:
-        opts = {}
-        opts[:symbol_keys] = options[:symbolize_keys]
-        ::Oj.load(string, opts)
-      end
-
-      def self.encode(object, options = {}) #:nodoc:
-        ::Oj.dump(object, options)
-      end
-    end
-  end
-end