multi_json 1.15.0 → 1.16.0

data/lib/multi_json/adapters/json_gem.rb

@@ -1,11 +1,34 @@
-require 'json/ext'
-require 'multi_json/adapters/json_common'
+require_relative "../adapter"
+require "json"
 
 module MultiJson
   module Adapters
     # Use the JSON gem to dump/load.
-    class JsonGem < JsonCommon
+    class JsonGem < Adapter
       ParseError = ::JSON::ParserError
+
+      defaults :load, create_additions: false, quirks_mode: true
+
+      PRETTY_STATE_PROTOTYPE = {
+        indent: "  ",
+        space: " ",
+        object_nl: "\n",
+        array_nl: "\n"
+      }.freeze
+      private_constant :PRETTY_STATE_PROTOTYPE
+
+      def load(string, options = {})
+        string = string.dup.force_encoding(Encoding::UTF_8) if string.encoding != Encoding::UTF_8
+
+        options[:symbolize_names] = true if options.delete(:symbolize_keys)
+        ::JSON.parse(string, options)
+      end
+
+      def dump(object, options = {})
+        options.merge!(PRETTY_STATE_PROTOTYPE) if options.delete(:pretty)
+
+        object.to_json(options)
+      end
     end
   end
 end

data/lib/multi_json/adapters/json_pure.rb

@@ -1,11 +1,7 @@
-require 'json/pure'
-require 'multi_json/adapters/json_common'
+require_relative "json_gem"
 
 module MultiJson
   module Adapters
-    # Use JSON pure to dump/load.
-    class JsonPure < JsonCommon
-      ParseError = ::JSON::ParserError
-    end
+    JsonPure = JsonGem
   end
 end

data/lib/multi_json/adapters/oj.rb

@@ -1,13 +1,12 @@
-require 'set'
-require 'oj'
-require 'multi_json/adapter'
+require "oj"
+require_relative "../adapter"
 
 module MultiJson
   module Adapters
     # Use the Oj library to dump/load.
     class Oj < Adapter
-      defaults :load, :mode => :strict, :symbolize_keys => false
-      defaults :dump, :mode => :compat, :time_format => :ruby, :use_to_json => true
+      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
@@ -18,14 +17,10 @@ module MultiJson
       # (at least for now).
       class ParseError < ::SyntaxError
         WRAPPED_CLASSES = %w[Oj::ParseError JSON::ParserError].to_set.freeze
+        private_constant :WRAPPED_CLASSES
 
         def self.===(exception)
-          case exception
-          when ::SyntaxError
-            true
-          else
-            WRAPPED_CLASSES.include?(exception.class.to_s)
-          end
+          exception.is_a?(::SyntaxError) || WRAPPED_CLASSES.include?(exception.class.to_s)
         end
       end
 
@@ -34,29 +29,34 @@ module MultiJson
         ::Oj.load(string, options)
       end
 
-      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\./
+      OJ_VERSION = ::Oj::VERSION
+      OJ_V2 = OJ_VERSION.start_with?("2.")
+      OJ_V3 = OJ_VERSION.start_with?("3.")
+      private_constant :OJ_VERSION, :OJ_V2, :OJ_V3
+
+      if OJ_V3
         PRETTY_STATE_PROTOTYPE = {
-          :indent                => "  ",
-          :space                 => " ",
-          :space_before          => "",
-          :object_nl             => "\n",
-          :array_nl              => "\n",
-          :ascii_only            => false,
-        }
-
-        def dump(object, options = {})
+          indent: "  ",
+          space: " ",
+          space_before: "",
+          object_nl: "\n",
+          array_nl: "\n",
+          ascii_only: false
+        }.freeze
+        private_constant :PRETTY_STATE_PROTOTYPE
+      end
+
+      def dump(object, options = {})
+        if OJ_V2
+          options[:indent] = 2 if options[:pretty]
+          options[:indent] = options[:indent].to_i if options[:indent]
+        elsif OJ_V3
           options.merge!(PRETTY_STATE_PROTOTYPE.dup) if options.delete(:pretty)
-          ::Oj.dump(object, options)
+        else
+          raise "Unsupported Oj version: #{::Oj::VERSION}"
         end
-      else
-        fail "Unsupported Oj version: #{::Oj::VERSION}"
+
+        ::Oj.dump(object, options)
       end
     end
   end

data/lib/multi_json/adapters/ok_json.rb

@@ -1,6 +1,6 @@
-require 'multi_json/adapter'
-require 'multi_json/convertible_hash_keys'
-require 'multi_json/vendor/okjson'
+require_relative "../adapter"
+require_relative "../convertible_hash_keys"
+require_relative "../vendor/okjson"
 
 module MultiJson
   module Adapters

data/lib/multi_json/adapters/yajl.rb

@@ -1,5 +1,5 @@
-require 'yajl'
-require 'multi_json/adapter'
+require "yajl"
+require_relative "../adapter"
 
 module MultiJson
   module Adapters
@@ -8,7 +8,7 @@ module MultiJson
       ParseError = ::Yajl::ParseError
 
       def load(string, options = {})
-        ::Yajl::Parser.new(:symbolize_keys => options[:symbolize_keys]).parse(string)
+        ::Yajl::Parser.new(symbolize_keys: options[:symbolize_keys]).parse(string)
       end
 
       def dump(object, options = {})

data/lib/multi_json/convertible_hash_keys.rb

@@ -1,6 +1,9 @@
 module MultiJson
   module ConvertibleHashKeys
-  private
+    SIMPLE_OBJECT_CLASSES = [String, Numeric, TrueClass, FalseClass, NilClass].freeze
+    private_constant :SIMPLE_OBJECT_CLASSES
+
+    private
 
     def symbolize_keys(hash)
       prepare_hash(hash) do |key|
@@ -14,30 +17,35 @@ module MultiJson
       end
     end
 
-    def prepare_hash(hash, &key_modifier)
-      return hash unless block_given?
-      case hash
+    def prepare_hash(value, &)
+      case value
       when Array
-        hash.map do |value|
-          prepare_hash(value, &key_modifier)
-        end
+        handle_array(value, &)
       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
+        handle_hash(value, &)
       else
-        if hash.respond_to?(:to_json)
-          hash
-        elsif hash.respond_to?(:to_s)
-          hash.to_s
-        else
-          hash
-        end
+        handle_simple_objects(value)
       end
     end
+
+    def handle_simple_objects(obj)
+      return obj if simple_object?(obj) || obj.respond_to?(:to_json)
+
+      obj.respond_to?(:to_s) ? obj.to_s : obj
+    end
+
+    def handle_array(array, &key_modifier)
+      array.map { |value| prepare_hash(value, &key_modifier) }
+    end
+
+    def handle_hash(original_hash, &key_modifier)
+      original_hash.each_with_object({}) do |(key, value), result|
+        result[key_modifier.call(key)] = prepare_hash(value, &key_modifier)
+      end
+    end
+
+    def simple_object?(obj)
+      SIMPLE_OBJECT_CLASSES.any? { |klass| obj.is_a?(klass) }
+    end
   end
 end

data/lib/multi_json/options.rb

@@ -10,30 +10,40 @@ module MultiJson
       @dump_options = options
     end
 
-    def load_options(*args)
-      defined?(@load_options) && get_options(@load_options, *args) || default_load_options
+    def load_options(*)
+      (defined?(@load_options) && get_options(@load_options, *)) || default_load_options
     end
 
-    def dump_options(*args)
-      defined?(@dump_options) && get_options(@dump_options, *args) || default_dump_options
+    def dump_options(*)
+      (defined?(@dump_options) && get_options(@dump_options, *)) || default_dump_options
     end
 
     def default_load_options
-      @default_load_options ||= {}
+      @default_load_options ||= {}.freeze
     end
 
     def default_dump_options
-      @default_dump_options ||= {}
+      @default_dump_options ||= {}.freeze
     end
 
-  private
+    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
+    def get_options(options, *)
+      return handle_callable_options(options, *) if options_callable?(options)
+
+      handle_hashable_options(options)
+    end
+
+    def options_callable?(options)
+      options.respond_to?(:call)
+    end
+
+    def handle_callable_options(options, *)
+      options.arity.zero? ? options.call : options.call(*)
+    end
+
+    def handle_hashable_options(options)
+      options.respond_to?(:to_hash) ? options.to_hash : nil
     end
   end
 end

data/lib/multi_json/options_cache.rb

@@ -1,29 +1,53 @@
 module MultiJson
   module OptionsCache
-    extend self
+    class Store
+      # 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
+      private_constant :MAX_CACHE_SIZE
 
-    def reset
-      @dump_cache = {}
-      @load_cache = {}
-    end
+      def initialize
+        @cache = {}
+        @mutex = Mutex.new
+      end
 
-    def fetch(type, key, &block)
-      cache = instance_variable_get("@#{type}_cache")
-      cache.key?(key) ? cache[key] : write(cache, key, &block)
-    end
+      def reset
+        @mutex.synchronize do
+          @cache = {}
+        end
+      end
+
+      def fetch(key, &)
+        @mutex.synchronize do
+          return @cache[key] if @cache.key?(key)
+        end
 
-    private
+        value = yield
 
-    # 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
+        @mutex.synchronize do
+          if @cache.key?(key)
+            # We ran into a race condition, keep the existing value
+            @cache[key]
+          else
+            @cache.clear if @cache.size >= MAX_CACHE_SIZE
+            @cache[key] = value
+          end
+        end
+      end
+    end
+
+    class << self
+      attr_reader :dump, :load
 
-    def write(cache, key)
-      cache.clear if cache.length >= MAX_CACHE_SIZE
-      cache[key] = yield
+      def reset
+        @dump = Store.new
+        @load = Store.new
+      end
     end
+
+    reset
   end
 end

data/lib/multi_json/parse_error.rb

@@ -1,15 +1,15 @@
 module MultiJson
   class ParseError < StandardError
-    attr_reader :data, :cause
+    attr_reader :data
+
+    def initialize(message = nil, data: nil, cause: nil)
+      super(message)
+      @data = data
+      set_backtrace(cause.backtrace) if cause
+    end
 
     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
+      new(original_exception.message, data: data, cause: original_exception)
     end
   end