multi_json 1.5.0 → 1.15.0

data/lib/multi_json/adapters/json_pure.rb

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

data/lib/multi_json/adapters/nsjsonserialization.rb

@@ -1,3 +1,6 @@
+# This adapter is here for legacy reasons. We can't really test it, so it's hard
+# to tell if it's even working properly. If you're still using it, please
+# consider migrating to any other adapter out there.
 framework 'Foundation'
 require 'multi_json/adapters/ok_json'
 
@@ -6,29 +9,27 @@ module MultiJson
     class Nsjsonserialization < MultiJson::Adapters::OkJson
       ParseError = ::MultiJson::OkJson::Error
 
-      def self.load(string, options={})
-        string = string.read if string.respond_to?(:read)
+      def load(string, options = {})
         data = string.dataUsingEncoding(NSUTF8StringEncoding)
-        object = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingMutableContainers | NSJSONReadingMutableLeaves, error: nil)
+        object = NSJSONSerialization.JSONObjectWithData(data, :options => NSJSONReadingMutableContainers | NSJSONReadingMutableLeaves, :error => nil)
         if object
           object = symbolize_keys(object) if options[:symbolize_keys]
           object
         else
-          super(string, options={})
+          super(string, options)
         end
       end
 
-      def self.dump(object, options={})
+      def dump(object, options = {})
         pretty = options[:pretty] ? NSJSONWritingPrettyPrinted : 0
         object = object.as_json if object.respond_to?(:as_json)
         if NSJSONSerialization.isValidJSONObject(object)
-          data = NSJSONSerialization.dataWithJSONObject(object, options: pretty, error: nil)
-          NSMutableString.alloc.initWithData(data, encoding: NSUTF8StringEncoding)
+          data = NSJSONSerialization.dataWithJSONObject(object, :options => pretty, :error => nil)
+          NSMutableString.alloc.initWithData(data, :encoding => NSUTF8StringEncoding)
         else
           super(object, options)
         end
       end
-
     end
   end
 end

data/lib/multi_json/adapters/oj.rb

@@ -1,25 +1,62 @@
-require 'oj' unless defined?(::Oj)
+require 'set'
+require 'oj'
+require 'multi_json/adapter'
 
 module MultiJson
   module Adapters
     # Use the Oj library to dump/load.
-    class Oj
-      ParseError = if defined?(::Oj::ParseError)
-        ::Oj::ParseError
-      else
-        SyntaxError
-      end
+    class Oj < Adapter
+      defaults :load, :mode => :strict, :symbolize_keys => false
+      defaults :dump, :mode => :compat, :time_format => :ruby, :use_to_json => true
+
+      # In certain cases OJ gem may throw JSON::ParserError exception instead
+      # of its own class. Also, we can't expect ::JSON::ParserError and
+      # ::Oj::ParseError to always be defined, since it's often not the case.
+      # Because of this, we can't reference those classes directly and have to
+      # do string comparison instead. This will not catch subclasses, but it
+      # shouldn't be a problem since the library is not known to be using it
+      # (at least for now).
+      class ParseError < ::SyntaxError
+        WRAPPED_CLASSES = %w[Oj::ParseError JSON::ParserError].to_set.freeze
 
-      ::Oj.default_options = {:mode => :compat}
+        def self.===(exception)
+          case exception
+          when ::SyntaxError
+            true
+          else
+            WRAPPED_CLASSES.include?(exception.class.to_s)
+          end
+        end
+      end
 
-      def self.load(string, options={}) #:nodoc:
-        options.merge!(:symbol_keys => options[:symbolize_keys])
+      def load(string, options = {})
+        options[:symbol_keys] = options[:symbolize_keys]
         ::Oj.load(string, options)
       end
 
-      def self.dump(object, options={}) #:nodoc:
-        options.merge!(:indent => 2) if options[:pretty]
-        ::Oj.dump(object, options)
+      case ::Oj::VERSION
+      when /\A2\./
+        def dump(object, options = {})
+          options.merge!(:indent => 2) if options[:pretty]
+          options[:indent] = options[:indent].to_i if options[:indent]
+          ::Oj.dump(object, options)
+        end
+      when /\A3\./
+        PRETTY_STATE_PROTOTYPE = {
+          :indent                => "  ",
+          :space                 => " ",
+          :space_before          => "",
+          :object_nl             => "\n",
+          :array_nl              => "\n",
+          :ascii_only            => false,
+        }
+
+        def dump(object, options = {})
+          options.merge!(PRETTY_STATE_PROTOTYPE.dup) if options.delete(:pretty)
+          ::Oj.dump(object, options)
+        end
+      else
+        fail "Unsupported Oj version: #{::Oj::VERSION}"
       end
     end
   end

data/lib/multi_json/adapters/ok_json.rb

@@ -1,48 +1,23 @@
+require 'multi_json/adapter'
+require 'multi_json/convertible_hash_keys'
 require 'multi_json/vendor/okjson'
 
 module MultiJson
   module Adapters
-    class OkJson
+    class OkJson < Adapter
+      include ConvertibleHashKeys
       ParseError = ::MultiJson::OkJson::Error
 
-      def self.load(string, options={}) #:nodoc:
-        string = string.read if string.respond_to?(:read)
+      def load(string, options = {})
         result = ::MultiJson::OkJson.decode("[#{string}]").first
         options[:symbolize_keys] ? symbolize_keys(result) : result
+      rescue ArgumentError # invalid byte sequence in UTF-8
+        raise ParseError
       end
 
-      def self.dump(object, options={}) #:nodoc:
+      def dump(object, _ = {})
         ::MultiJson::OkJson.valenc(stringify_keys(object))
       end
-
-      def self.symbolize_keys(object) #:nodoc:
-        modify_keys(object) do |key|
-          key.is_a?(String) ? key.to_sym : key
-        end
-      end
-
-      def self.stringify_keys(object) #:nodoc:
-        modify_keys(object) do |key|
-          key.respond_to?(:to_s) ? key.to_s : key
-        end
-      end
-
-      def self.modify_keys(object, &modifier) #:nodoc:
-        case object
-        when Array
-          object.map do |value|
-            modify_keys(value, &modifier)
-          end
-        when Hash
-          object.inject({}) do |result, (key, value)|
-            new_key   = modifier.call(key)
-            new_value = modify_keys(value, &modifier)
-            result.merge! new_key => new_value
-          end
-        else
-          object
-        end
-      end
     end
   end
 end

data/lib/multi_json/adapters/yajl.rb

@@ -1,16 +1,17 @@
-require 'yajl' unless defined?(::Yajl)
+require 'yajl'
+require 'multi_json/adapter'
 
 module MultiJson
   module Adapters
     # Use the Yajl-Ruby library to dump/load.
-    class Yajl
+    class Yajl < Adapter
       ParseError = ::Yajl::ParseError
 
-      def self.load(string, options={}) #:nodoc:
+      def load(string, options = {})
         ::Yajl::Parser.new(:symbolize_keys => options[:symbolize_keys]).parse(string)
       end
 
-      def self.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(hash)
+      prepare_hash(hash) do |key|
+        key.respond_to?(:to_sym) ? key.to_sym : key
+      end
+    end
+
+    def stringify_keys(hash)
+      prepare_hash(hash) do |key|
+        key.respond_to?(:to_s) ? key.to_s : key
+      end
+    end
+
+    def prepare_hash(hash, &key_modifier)
+      return hash unless block_given?
+      case hash
+      when Array
+        hash.map do |value|
+          prepare_hash(value, &key_modifier)
+        end
+      when Hash
+        hash.inject({}) do |result, (key, value)|
+          new_key   = key_modifier.call(key)
+          new_value = prepare_hash(value, &key_modifier)
+          result.merge! new_key => new_value
+        end
+      when String, Numeric, true, false, nil
+        hash
+      else
+        if hash.respond_to?(:to_json)
+          hash
+        elsif hash.respond_to?(:to_s)
+          hash.to_s
+        else
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/multi_json/options.rb

@@ -0,0 +1,39 @@
+module MultiJson
+  module Options
+    def load_options=(options)
+      OptionsCache.reset
+      @load_options = options
+    end
+
+    def dump_options=(options)
+      OptionsCache.reset
+      @dump_options = options
+    end
+
+    def load_options(*args)
+      defined?(@load_options) && get_options(@load_options, *args) || default_load_options
+    end
+
+    def dump_options(*args)
+      defined?(@dump_options) && get_options(@dump_options, *args) || default_dump_options
+    end
+
+    def default_load_options
+      @default_load_options ||= {}
+    end
+
+    def default_dump_options
+      @default_dump_options ||= {}
+    end
+
+  private
+
+    def get_options(options, *args)
+      if options.respond_to?(:call) && options.arity
+        options.arity == 0 ? options[] : options[*args]
+      elsif options.respond_to?(:to_hash)
+        options.to_hash
+      end
+    end
+  end
+end

data/lib/multi_json/options_cache.rb

@@ -0,0 +1,29 @@
+module MultiJson
+  module OptionsCache
+    extend self
+
+    def reset
+      @dump_cache = {}
+      @load_cache = {}
+    end
+
+    def fetch(type, key, &block)
+      cache = instance_variable_get("@#{type}_cache")
+      cache.key?(key) ? cache[key] : write(cache, key, &block)
+    end
+
+    private
+
+    # Normally MultiJson is used with a few option sets for both dump/load
+    # methods. When options are generated dynamically though, every call would
+    # cause a cache miss and the cache would grow indefinitely. To prevent
+    # this, we just reset the cache every time the number of keys outgrows
+    # 1000.
+    MAX_CACHE_SIZE = 1000
+
+    def write(cache, key)
+      cache.clear if cache.length >= MAX_CACHE_SIZE
+      cache[key] = yield
+    end
+  end
+end

data/lib/multi_json/parse_error.rb

@@ -0,0 +1,17 @@
+module MultiJson
+  class ParseError < StandardError
+    attr_reader :data, :cause
+
+    def self.build(original_exception, data)
+      new(original_exception.message).tap do |exception|
+        exception.instance_eval do
+          @cause = original_exception
+          set_backtrace original_exception.backtrace
+          @data = data
+        end
+      end
+    end
+  end
+
+  DecodeError = LoadError = ParseError # Legacy support
+end

data/lib/multi_json/vendor/okjson.rb

@@ -24,11 +24,12 @@
 
 require 'stringio'
 
-# Some parts adapted from
-# http://golang.org/src/pkg/json/decode.go and
-# http://golang.org/src/pkg/utf8/utf8.go
 module MultiJson
+  # Some parts adapted from
+  # https://golang.org/src/encoding/json/decode.go and
+  # https://golang.org/src/unicode/utf8/utf8.go
   module OkJson
+    Upstream = '45'
     extend self
 
 
@@ -50,12 +51,53 @@ module MultiJson
     end
 
 
+    # Encodes x into a json text. It may contain only
+    # Array, Hash, String, Numeric, true, false, nil.
+    # (Note, this list excludes Symbol.)
+    # X itself must be an Array or a Hash.
+    # No other value can be encoded, and an error will
+    # be raised if x contains any other value, such as
+    # Nan, Infinity, Symbol, and Proc, or if a Hash key
+    # is not a String.
+    # Strings contained in x must be valid UTF-8.
+    def encode(x)
+      case x
+      when Hash    then objenc(x)
+      when Array   then arrenc(x)
+      else
+        raise Error, 'root value must be an Array or a Hash'
+      end
+    end
+
+
+    def valenc(x)
+      case x
+      when Hash    then objenc(x)
+      when Array   then arrenc(x)
+      when String  then strenc(x)
+      when Numeric then numenc(x)
+      when true    then "true"
+      when false   then "false"
+      when nil     then "null"
+      else
+        if x.respond_to?(:to_json)
+          x.to_json
+        else
+          raise Error, "cannot encode #{x.class}: #{x.inspect}"
+        end
+      end
+    end
+
+
+  private
+
+
     # Parses a "json text" in the sense of RFC 4627.
     # Returns the parsed value and any trailing tokens.
     # Note: this is almost the same as valparse,
     # except that it does not accept atomic values.
     def textparse(ts)
-      if ts.length < 0
+      if ts.length <= 0
         raise Error, 'empty'
       end
 
@@ -72,7 +114,7 @@ module MultiJson
     # Parses a "value" in the sense of RFC 4627.
     # Returns the parsed value and any trailing tokens.
     def valparse(ts)
-      if ts.length < 0
+      if ts.length <= 0
         raise Error, 'empty'
       end
 
@@ -201,21 +243,19 @@ module MultiJson
     # it is the lexeme.
     def tok(s)
       case s[0]
-      when ?{  then ['{', s[0,1], s[0,1]]
-      when ?}  then ['}', s[0,1], s[0,1]]
-      when ?:  then [':', s[0,1], s[0,1]]
-      when ?,  then [',', s[0,1], s[0,1]]
-      when ?[  then ['[', s[0,1], s[0,1]]
-      when ?]  then [']', s[0,1], s[0,1]]
-      when ?n  then nulltok(s)
-      when ?t  then truetok(s)
-      when ?f  then falsetok(s)
-      when ?"  then strtok(s)
-      when Spc then [:space, s[0,1], s[0,1]]
-      when ?\t then [:space, s[0,1], s[0,1]]
-      when ?\n then [:space, s[0,1], s[0,1]]
-      when ?\r then [:space, s[0,1], s[0,1]]
-      else          numtok(s)
+      when ?{ then ['{', s[0,1], s[0,1]]
+      when ?} then ['}', s[0,1], s[0,1]]
+      when ?: then [':', s[0,1], s[0,1]]
+      when ?, then [',', s[0,1], s[0,1]]
+      when ?[ then ['[', s[0,1], s[0,1]]
+      when ?] then [']', s[0,1], s[0,1]]
+      when ?n then nulltok(s)
+      when ?t then truetok(s)
+      when ?f then falsetok(s)
+      when ?" then strtok(s)
+      when Spc, ?\t, ?\n, ?\r then [:space, s[0,1], s[0,1]]
+      else
+        numtok(s)
       end
     end
 
@@ -226,14 +266,14 @@ module MultiJson
 
 
     def numtok(s)
-      m = /-?([1-9][0-9]+|[0-9])([.][0-9]+)?([eE][+-]?[0-9]+)?/.match(s)
+      m = /(-?(?:[1-9][0-9]+|[0-9]))([.][0-9]+)?([eE][+-]?[0-9]+)?/.match(s)
       if m && m.begin(0) == 0
-        if m[3] && !m[2]
-          [:val, m[0], Integer(m[1])*(10**Integer(m[3][1..-1]))]
+        if !m[2] && !m[3]
+          [:val, m[0], Integer(m[0])]
         elsif m[2]
           [:val, m[0], Float(m[0])]
         else
-          [:val, m[0], Integer(m[0])]
+          [:val, m[0], Integer(m[1])*(10**m[3][1..-1].to_i(10))]
         end
       else
         []
@@ -265,17 +305,14 @@ 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)
+      if rubydoesenc?
         a.force_encoding('UTF-8')
-        rubydoesenc = true
       end
       r, w = 0, 0
       while r < q.length
         c = q[r]
-        case true
-        when c == ?\\
+        if c == ?\\
           r += 1
           if r >= q.length
             raise Error, "string literal ends with a \"\\\": \"#{q}\""
@@ -308,7 +345,7 @@ module MultiJson
                 end
               end
             end
-            if rubydoesenc
+            if rubydoesenc?
               a[w] = '' << uchar
               w += 1
             else
@@ -317,7 +354,7 @@ module MultiJson
           else
             raise Error, "invalid escape char #{q[r]} in \"#{q}\""
           end
-        when c == ?", c < Spc
+        elsif c == ?" || c < Spc
           raise Error, "invalid character in string literal \"#{q}\""
         else
           # Copy anything else byte-for-byte.
@@ -338,15 +375,14 @@ module MultiJson
     # bytes in string a at position i.
     # Returns the number of bytes written.
     def ucharenc(a, i, u)
-      case true
-      when u <= Uchar1max
+      if u <= Uchar1max
         a[i] = (u & 0xff).chr
         1
-      when u <= Uchar2max
+      elsif u <= Uchar2max
         a[i+0] = (Utag2 | ((u>>6)&0xff)).chr
         a[i+1] = (Utagx | (u&Umaskx)).chr
         2
-      when u <= Uchar3max
+      elsif u <= Uchar3max
         a[i+0] = (Utag3 | ((u>>12)&0xff)).chr
         a[i+1] = (Utagx | ((u>>6)&Umaskx)).chr
         a[i+2] = (Utagx | (u&Umaskx)).chr
@@ -383,54 +419,15 @@ module MultiJson
 
 
     def nibble(c)
-      case true
-      when ?0 <= c && c <= ?9 then c.ord - ?0.ord
-      when ?a <= c && c <= ?z then c.ord - ?a.ord + 10
-      when ?A <= c && c <= ?Z then c.ord - ?A.ord + 10
+      if ?0 <= c && c <= ?9 then c.ord - ?0.ord
+      elsif ?a <= c && c <= ?z then c.ord - ?a.ord + 10
+      elsif ?A <= c && c <= ?Z then c.ord - ?A.ord + 10
       else
         raise Error, "invalid hex code #{c}"
       end
     end
 
 
-    # Encodes x into a json text. It may contain only
-    # Array, Hash, String, Numeric, true, false, nil.
-    # (Note, this list excludes Symbol.)
-    # X itself must be an Array or a Hash.
-    # No other value can be encoded, and an error will
-    # be raised if x contains any other value, such as
-    # Nan, Infinity, Symbol, and Proc, or if a Hash key
-    # is not a String.
-    # Strings contained in x must be valid UTF-8.
-    def encode(x)
-      case x
-      when Hash    then objenc(x)
-      when Array   then arrenc(x)
-      else
-        raise Error, 'root value must be an Array or a Hash'
-      end
-    end
-
-
-    def valenc(x)
-      case x
-      when Hash    then objenc(x)
-      when Array   then arrenc(x)
-      when String  then strenc(x)
-      when Numeric then numenc(x)
-      when true    then "true"
-      when false   then "false"
-      when nil     then "null"
-      else
-        if x.respond_to?(:to_json)
-          x.to_json
-        else
-          raise Error, "cannot encode #{x.class}: #{x.inspect}"
-        end
-      end
-    end
-
-
     def objenc(x)
       '{' + x.map{|k,v| keyenc(k) + ':' + valenc(v)}.join(',') + '}'
     end
@@ -455,9 +452,6 @@ module MultiJson
       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('\\"')
@@ -469,15 +463,20 @@ module MultiJson
         when ?\t then t.print('\\t')
         else
           c = s[r]
-          case true
-          when rubydoesenc
+          # In ruby >= 1.9, s[r] is a codepoint, not a byte.
+          if rubydoesenc?
             begin
-              c.ord # will raise an error if c is invalid UTF-8
+              # c.ord will raise an error if c is invalid UTF-8
+              if c.ord < Spc.ord
+                c = "\\u%04x" % [c.ord]
+              end
               t.write(c)
             rescue
               t.write(Ustrerr)
             end
-          when Spc <= c && c <= ?~
+          elsif c < Spc
+            t.write("\\u%04x" % c)
+          elsif Spc <= c && c <= ?~
             t.putc(c)
           else
             n = ucharcopy(t, s, r) # ensure valid UTF-8 output
@@ -569,6 +568,11 @@ module MultiJson
     end
 
 
+    def rubydoesenc?
+      ::String.method_defined?(:force_encoding)
+    end
+
+
     class Utf8Error < ::StandardError
     end
 
@@ -577,15 +581,15 @@ module MultiJson
     end
 
 
-    Utagx = 0x80 # 1000 0000
-    Utag2 = 0xc0 # 1100 0000
-    Utag3 = 0xe0 # 1110 0000
-    Utag4 = 0xf0 # 1111 0000
-    Utag5 = 0xF8 # 1111 1000
-    Umaskx = 0x3f # 0011 1111
-    Umask2 = 0x1f # 0001 1111
-    Umask3 = 0x0f # 0000 1111
-    Umask4 = 0x07 # 0000 0111
+    Utagx = 0b1000_0000
+    Utag2 = 0b1100_0000
+    Utag3 = 0b1110_0000
+    Utag4 = 0b1111_0000
+    Utag5 = 0b1111_1000
+    Umaskx = 0b0011_1111
+    Umask2 = 0b0001_1111
+    Umask3 = 0b0000_1111
+    Umask4 = 0b0000_0111
     Uchar1max = (1<<7) - 1
     Uchar2max = (1<<11) - 1
     Uchar3max = (1<<16) - 1

data/lib/multi_json/version.rb

@@ -1,3 +1,17 @@
 module MultiJson
-  VERSION = "1.5.0" unless defined?(MultiJson::VERSION)
+  class Version
+    MAJOR = 1 unless defined? MultiJson::Version::MAJOR
+    MINOR = 15 unless defined? MultiJson::Version::MINOR
+    PATCH = 0 unless defined? MultiJson::Version::PATCH
+    PRE = nil unless defined? MultiJson::Version::PRE
+
+    class << self
+      # @return [String]
+      def to_s
+        [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+      end
+    end
+  end
+
+  VERSION = Version.to_s.freeze
 end