multi_json 1.20.1 → 1.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbba8097011550d30c5962bdd828a95b431ab54cc9a6d831844e78c78f2ddc74
-  data.tar.gz: 767ba488de4f71c7503d69126130b88d904f656ec12cd2b0c039a1d66c39e594
+  metadata.gz: 6eb65ee97a46816e1bfe43fbeff173a83846bb1ff85e3c5e4fe97c80cec4dacf
+  data.tar.gz: 9eedd9bd17375a5540dc4878613a9165e49925d1997c24f4d9776f41efb1d7f0
 SHA512:
-  metadata.gz: a0e46b45475da5fa524fdfc00c02b10bf9a3c677d3702bf81fa1bfaef278dc219a7720f082cc1a8edbc5fe07e2aa83e92a87ec2a7057a42edabd90a211fde34e
-  data.tar.gz: 650953b9efc5ba89c84cb751c206972e8d95923c5b466558a97c340666a31b71645943e83b0186076cbf9a843da3dd306c3fdb654911873797bedf89e763e7d7
+  metadata.gz: c727bce3f895367c1092319c4725dedde9252706cc6da7a5d8b1ef4bef5abb025869b7a04dc44218dfe53198b8da0c0c36e1d61037824a34a59dcfd78a030f68
+  data.tar.gz: 2dc0b84560382d05f58549875227be1dbc32c274172f2c67e4c395f4baede84217061a10fcf22ebd078ce7e89fb25a88e067f7424b4bdd830c75081e96d2938f

data/README.md

@@ -16,22 +16,33 @@ fastest available JSON coder. Here's how to use it:
 ```ruby
 require "multi_json"
 
-MultiJson.load('{"abc":"def"}')                       #=> {"abc" => "def"}
-MultiJson.load('{"abc":"def"}', symbolize_keys: true) #=> {abc: "def"}
-MultiJson.dump({abc: "def"})                          # convert Ruby back to JSON
-MultiJson.dump({abc: "def"}, pretty: true)            # encoded in a pretty form (if supported by the coder)
+MultiJSON.parse('{"abc":"def"}')                        #=> {"abc" => "def"}
+MultiJSON.parse('{"abc":"def"}', symbolize_names: true) #=> {abc: "def"}
+MultiJSON.generate({abc: "def"})                       # convert Ruby back to JSON
+MultiJSON.generate({abc: "def"}, pretty: true)         # encoded in a pretty form (if supported by the coder)
 ```
 
-`MultiJson.load` returns `nil` for `nil`, empty, and whitespace-only inputs
+> [!IMPORTANT]
+> **1.21.0 renames the public API to match Ruby stdlib `JSON`.** The canonical
+> verbs are now `MultiJSON.parse` / `MultiJSON.generate`, and the canonical
+> module is `MultiJSON` (all-caps). The legacy `MultiJson` constant,
+> `MultiJSON.load` / `MultiJSON.dump`, `:symbolize_keys`, and friends still
+> work but emit one-time deprecation warnings and **will be removed in 2.0.0**.
+> Run your app with `ruby -W:deprecated` to surface them; the warnings are
+> tagged with the `:deprecated` category so you can silence the whole set with
+> `Warning[:deprecated] = false`. See [Deprecated in 1.21.0](#deprecated-in-1210)
+> for the full list.
+
+`MultiJSON.parse` returns `nil` for `nil`, empty, and whitespace-only inputs
 instead of raising, so a missing or blank payload is observable as a `nil`
-return value rather than an exception. When loading invalid JSON, MultiJSON
-will throw a `MultiJson::ParseError`. `MultiJson::DecodeError` and
-`MultiJson::LoadError` are aliases for backwards compatibility.
+return value rather than an exception. When parsing invalid JSON, MultiJSON
+will throw a `MultiJSON::ParseError`. `MultiJSON::DecodeError` and
+`MultiJSON::LoadError` are aliases for backwards compatibility.
 
 ```ruby
 begin
-  MultiJson.load("{invalid json}")
-rescue MultiJson::ParseError => exception
+  MultiJSON.parse("{invalid json}")
+rescue MultiJSON::ParseError => exception
   exception.data    #=> "{invalid json}"
   exception.cause   #=> JSON::ParserError: ...
   exception.line    #=> 1 (for adapters that report a location, e.g. Oj or the json gem)
@@ -39,6 +50,61 @@ rescue MultiJson::ParseError => exception
 end
 ```
 
+### Drop-in replacement for stdlib `JSON`
+
+MultiJSON mirrors the surface of Ruby's stdlib [`JSON`][json-gem] so
+most call sites swap in with a one-line change:
+
+```diff
+- require "json"
++ require "multi_json"
+
+- JSON.parse(text, symbolize_names: true)
++ MultiJSON.parse(text, symbolize_names: true)
+
+- JSON.generate(object, pretty: true)
++ MultiJSON.generate(object, pretty: true)
+```
+
+Method names and the common options line up with stdlib so existing
+pretty-print calls and option keys keep working without changes:
+
+| stdlib `JSON`          | `MultiJSON`                | Status |
+| ---------------------- | -------------------------- | :---:  |
+| `JSON.parse(str)`      | `MultiJSON.parse(str)`     | ✓ |
+| `JSON.generate(obj)`   | `MultiJSON.generate(obj)`  | ✓ |
+| `pretty: true`         | `pretty: true`             | ✓ |
+| `symbolize_names: true` | `symbolize_names: true`   | ✓ |
+
+### Deprecated in 1.21.0
+
+The module constant and primary verbs were renamed to match Ruby
+stdlib `JSON.parse` / `JSON.generate` and the JSON spec (RFC 8259).
+The old names still work in 1.x but now emit a one-time deprecation
+warning; **they will be removed in 2.0.0**.
+
+| Deprecated                    | Use instead                     |
+| ----------------------------- | ------------------------------- |
+| `MultiJson` (constant)        | `MultiJSON` (all-caps)          |
+| `MultiJSON.load(str)`         | `MultiJSON.parse(str)`          |
+| `MultiJSON.dump(obj)`         | `MultiJSON.generate(obj)`       |
+| `MultiJSON.load_options=`     | `MultiJSON.parse_options=`      |
+| `MultiJSON.load_options`      | `MultiJSON.parse_options`       |
+| `MultiJSON.dump_options=`     | `MultiJSON.generate_options=`   |
+| `MultiJSON.dump_options`      | `MultiJSON.generate_options`    |
+| `symbolize_keys:` option      | `symbolize_names:` option       |
+
+The `MultiJson` constant (CamelCase) continues to work as a thin
+delegator; every method call, constant lookup, and rescue clause
+routes through `MultiJSON` transparently.
+
+> [!TIP]
+> The recommended upgrade path to 2.0 is: pin `~> 1.21` first, run
+> `ruby -W:deprecated` against your app or test suite to surface every
+> deprecation, migrate each call site to the canonical name, then bump to
+> `~> 2.0`. The 2.0 release deletes the deprecated aliases entirely, so the
+> warnings during 1.21.x are your map.
+
 `ParseError` instance has `cause` reader which contains the original exception.
 It also has `data` reader with the input that caused the problem, and `line`/`column`
 readers populated for adapters whose error messages include a location (Oj and the
@@ -46,13 +112,13 @@ json gem). Adapters that don't include one (Yajl, fast_jsonparser) leave both ni
 
 ### Tuning the options cache
 
-MultiJSON memoizes the merged option hash for each `load`/`dump` call so identical
-option hashes don't trigger repeated work. The cache is bounded — defaulting to 1000
-entries per direction — and applications that generate many distinct option hashes
-can raise the ceiling at runtime:
+MultiJSON memoizes the merged option hash for each `parse`/`generate` call so
+identical option hashes don't trigger repeated work. The cache is bounded —
+defaulting to 1000 entries per direction — and applications that generate many
+distinct option hashes can raise the ceiling at runtime:
 
 ```ruby
-MultiJson::OptionsCache.max_cache_size = 5000
+MultiJSON::OptionsCache.max_cache_size = 5000
 ```
 
 `max_cache_size` must be a positive integer; `0`, negative values, and
@@ -60,14 +126,14 @@ non-integers raise `ArgumentError`.
 
 Lowering the limit only takes effect for *new* inserts; existing cache
 entries are left in place until normal eviction trims them below the
-new ceiling. Call `MultiJson::OptionsCache.reset` if you want to evict
+new ceiling. Call `MultiJSON::OptionsCache.reset` if you want to evict
 immediately.
 
 The `use` method, which sets the MultiJSON adapter, takes either a symbol or a
 class (to allow for custom JSON parsers) that responds to both `.load` and `.dump`
 at the class level.
 
-When MultiJSON fails to load the specified adapter, it'll throw `MultiJson::AdapterError`
+When MultiJSON fails to load the specified adapter, it'll throw `MultiJSON::AdapterError`
 which inherits from `ArgumentError`.
 
 ### Writing a custom adapter
@@ -88,38 +154,49 @@ class MyAdapter
   end
 end
 
-MultiJson.use(MyAdapter)
+MultiJSON.use(MyAdapter)
 ```
 
-`ParseError` is required: `MultiJson.load` rescues `MyAdapter::ParseError`
-to wrap parse failures in `MultiJson::ParseError`, and an adapter that
-omits the constant raises `MultiJson::AdapterError` on the first parse
+`ParseError` is required: `MultiJSON.parse` rescues `MyAdapter::ParseError`
+to wrap parse failures in `MultiJSON::ParseError`, and an adapter that
+omits the constant raises `MultiJSON::AdapterError` on the first parse
 attempt instead of producing a confusing `NameError`.
 
-For more, inherit from `MultiJson::Adapter` to pick up shared option
+For more, inherit from `MultiJSON::Adapter` to pick up shared option
 merging, the `defaults :load, ...` / `defaults :dump, ...` DSL, and the
 blank-input short-circuit. The built-in adapters in
 `lib/multi_json/adapters/` are working examples.
 
+> [!NOTE]
+> The adapter contract methods on the adapter class itself stay named
+> `.load` / `.dump` in 1.21.x (and the `defaults :load, ...` / `defaults
+> :dump, ...` DSL keys match). The 2.0 release renames them to `.parse` /
+> `.generate` to align with the public API; if you ship a custom adapter,
+> you'll need to rename those methods (and the `defaults` keys) when you
+> upgrade.
+
 MultiJSON tries to have intelligent defaulting. If any supported library is
 already loaded, MultiJSON uses it before attempting to load others. When no
 backend is preloaded, MultiJSON walks its preference list and uses the first
-one that loads successfully:
-
-1. `fast_jsonparser`
-2. `oj`
-3. `yajl-ruby`
-4. `jrjackson`
-5. The JSON gem
-6. `gson`
-
-This order is a best-effort historical ranking by typical parse/dump
-throughput on representative workloads, not a guaranteed benchmark. Real-world
-performance depends on the document shape, the Ruby implementation, and
-whether you're calling `load` or `dump`. The JSON gem is a Ruby default gem,
-so it's always available as a last-resort fallback on any supported Ruby. If
-you have a workload where a different backend is faster, set it explicitly
-with `MultiJson.use(:your_adapter)`.
+one that loads successfully. The list is split per platform — JRuby's
+available adapter set differs from MRI's, and the bundled benchmark suite
+ranks `json_gem` ahead of `fast_jsonparser`/`oj`/`yajl` on Ruby 3.4+. CI
+re-runs the benchmark and fails if the observed ranking diverges from the
+table below.
+
+| rank | MRI / TruffleRuby | JRuby           |
+| ---- | ----------------- | --------------- |
+| 1    | The JSON gem      | `jrjackson`     |
+| 2    | `fast_jsonparser` | The JSON gem    |
+| 3    | `oj`              | `gson`          |
+| 4    | `yajl-ruby`       | —               |
+
+A dash means the adapter isn't usable on that runtime: `fast_jsonparser`,
+`oj`, and `yajl-ruby` are MRI/TruffleRuby C extensions with no JRuby builds;
+`jrjackson` and `gson` are JRuby-only. The JSON gem is a Ruby default gem,
+so it's always available as a last-resort fallback on any supported Ruby.
+If you have a workload where a different backend is faster, set it
+explicitly with `MultiJSON.use(:your_adapter)`.
 
 ## Gem Variants
 

data/lib/multi_json/adapter.rb

@@ -3,7 +3,7 @@
 require "singleton"
 require_relative "options"
 
-module MultiJson
+module MultiJSON
   # Base class for JSON adapter implementations
   #
   # Each adapter wraps a specific JSON library (Oj, JSON gem, etc.) and
@@ -24,7 +24,7 @@ module MultiJson
       VALID_DEFAULTS_ACTIONS = %i[load dump].freeze
       private_constant :BLANK_PATTERN, :VALID_DEFAULTS_ACTIONS
 
-      # Get default load options, walking the superclass chain
+      # Get default parse options, walking the superclass chain
       #
       # Returns the closest ancestor's `@default_load_options` ivar so a
       # parent class calling {.defaults} after a subclass has been
@@ -33,18 +33,36 @@ module MultiJson
       #
       # @api private
       # @return [Hash] frozen options hash
-      def default_load_options
+      def default_parse_options
         walk_default_options(:@default_load_options)
       end
 
-      # Get default dump options, walking the superclass chain
+      # Get default generate options, walking the superclass chain
       #
       # @api private
       # @return [Hash] frozen options hash
-      def default_dump_options
+      def default_generate_options
         walk_default_options(:@default_dump_options)
       end
 
+      # Get default parse options, walking the superclass chain
+      #
+      # @api private
+      # @deprecated Use {.default_parse_options} instead. Will be removed in v2.0.
+      # @return [Hash] frozen options hash
+      def default_load_options
+        default_parse_options
+      end
+
+      # Get default generate options, walking the superclass chain
+      #
+      # @api private
+      # @deprecated Use {.default_generate_options} instead. Will be removed in v2.0.
+      # @return [Hash] frozen options hash
+      def default_dump_options
+        default_generate_options
+      end
+
       # DSL for setting adapter-specific default options
       #
       # ``action`` must be ``:load`` or ``:dump``; ``value`` must be a
@@ -59,7 +77,7 @@ module MultiJson
       # @raise [ArgumentError] when action is anything other than :load
       #   or :dump, or when value isn't a Hash
       # @example Set load defaults for an adapter
-      #   class MyAdapter < MultiJson::Adapter
+      #   class MyAdapter < MultiJSON::Adapter
       #     defaults :load, symbolize_keys: false
       #   end
       def defaults(action, value)
@@ -139,7 +157,7 @@ module MultiJson
         BLANK_PATTERN.match?(input.valid_encoding? ? input : input.scrub)
       end
 
-      # Merges dump options from adapter, global, and call-site
+      # Merges generate options from adapter, global, and call-site
       #
       # @api private
       # @param options [Hash] call-site options
@@ -147,11 +165,18 @@ module MultiJson
       def merged_dump_options(options)
         cache_key = strip_adapter_key(options)
         OptionsCache.dump.fetch(cache_key) do
-          dump_options(cache_key).merge(MultiJson.dump_options(cache_key)).merge!(cache_key)
+          generate_options(cache_key).merge(MultiJSON.generate_options(cache_key)).merge!(cache_key)
         end
       end
 
-      # Merges load options from adapter, global, and call-site
+      # Merges parse options from adapter, global, and call-site
+      #
+      # Each layer is normalized first so a deprecated ``:symbolize_keys``
+      # key in any source becomes the canonical ``:symbolize_names`` —
+      # done per-layer rather than post-merge so the expected override
+      # semantics (call-site > global > adapter default) still apply
+      # when a caller mixes the deprecated and canonical names across
+      # layers.
       #
       # @api private
       # @param options [Hash] call-site options
@@ -159,10 +184,37 @@ module MultiJson
       def merged_load_options(options)
         cache_key = strip_adapter_key(options)
         OptionsCache.load.fetch(cache_key) do
-          load_options(cache_key).merge(MultiJson.load_options(cache_key)).merge!(cache_key)
+          adapter = normalize_symbolize_option(parse_options(cache_key))
+          global = normalize_symbolize_option(MultiJSON.parse_options(cache_key))
+          call_site = normalize_symbolize_option(cache_key)
+          adapter.merge(global).merge!(call_site)
         end
       end
 
+      # Translate the deprecated ``:symbolize_keys`` option to ``:symbolize_names``
+      #
+      # Matches Ruby stdlib's ``JSON.parse`` naming. Emits a one-time
+      # deprecation warning on first encounter of ``:symbolize_keys``.
+      # When both names appear in the same layer (unusual — only
+      # possible if the caller explicitly set both), the canonical
+      # ``:symbolize_names`` value wins and ``:symbolize_keys`` is
+      # silently dropped.
+      #
+      # @api private
+      # @param options [Hash] options layer to normalize
+      # @return [Hash] hash with ``:symbolize_keys`` translated, or the
+      #   original hash when no translation is needed
+      def normalize_symbolize_option(options)
+        return options unless options.key?(:symbolize_keys)
+
+        MultiJSON.warn_deprecation_once(:symbolize_keys_option,
+          "The :symbolize_keys option is deprecated and will be removed in v2.0. Use :symbolize_names instead.")
+
+        new_opts = options.except(:symbolize_keys)
+        new_opts[:symbolize_names] = options[:symbolize_keys] unless new_opts.key?(:symbolize_names)
+        new_opts
+      end
+
       # Removes the :adapter key from options for cache key
       #
       # Returns a shared frozen empty hash for the common no-options call

data/lib/multi_json/adapter_error.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module MultiJson
+module MultiJSON
   # Raised when an adapter cannot be loaded or is not recognized
   #
   # @api public

data/lib/multi_json/adapter_selector.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module MultiJson
+module MultiJSON
   # Handles adapter discovery, loading, and selection
   #
   # Adapters can be specified as:
@@ -17,14 +17,34 @@ module MultiJson
     # constant whose presence indicates the backing library is already
     # loaded. ``loaded`` is a ``::``-separated path so we can walk it
     # without an explicit ``defined?`` check.
-    ADAPTERS = {
-      fast_jsonparser: {require: "fast_jsonparser", loaded: "FastJsonparser"},
-      oj: {require: "oj", loaded: "Oj"},
-      yajl: {require: "yajl", loaded: "Yajl"},
-      jr_jackson: {require: "jrjackson", loaded: "JrJackson"},
-      json_gem: {require: "json", loaded: "JSON::Ext::Parser"},
-      gson: {require: "gson", loaded: "Gson"}
-    }.freeze
+    #
+    # The hash order is split per platform: on MRI/TruffleRuby the
+    # bundled benchmark suite ranks json_gem ahead of fast_jsonparser/
+    # oj/yajl on Ruby 3.4+; on JRuby the FFI-vs-pure-Ruby tradeoff
+    # hasn't been re-benchmarked yet, so jr_jackson stays first there.
+    # CI re-runs the benchmark with ``--verify-preference`` to fail
+    # if the observed ranking diverges.
+    # :nocov:
+    ADAPTERS = if RUBY_ENGINE == "jruby"
+      {
+        jr_jackson: {require: "jrjackson", loaded: "JrJackson"},
+        json_gem: {require: "json", loaded: "JSON::Ext::Parser"},
+        gson: {require: "gson", loaded: "Gson"},
+        fast_jsonparser: {require: "fast_jsonparser", loaded: "FastJsonparser"},
+        oj: {require: "oj", loaded: "Oj"},
+        yajl: {require: "yajl", loaded: "Yajl"}
+      }.freeze
+    else
+      {
+        json_gem: {require: "json", loaded: "JSON::Ext::Parser"},
+        fast_jsonparser: {require: "fast_jsonparser", loaded: "FastJsonparser"},
+        oj: {require: "oj", loaded: "Oj"},
+        yajl: {require: "yajl", loaded: "Yajl"},
+        jr_jackson: {require: "jrjackson", loaded: "JrJackson"},
+        gson: {require: "gson", loaded: "Gson"}
+      }.freeze
+    end
+    # :nocov:
     private_constant :ADAPTERS
 
     # Backwards-compatible view of {ADAPTERS} that exposes only the
@@ -46,13 +66,13 @@ module MultiJson
     #
     # Used by adapters that only implement one direction (e.g.
     # FastJsonparser only parses) so the other direction can be delegated
-    # to whichever library MultiJson would otherwise pick.
+    # to whichever library MultiJSON would otherwise pick.
     #
     # @api private
     # @param excluded [Symbol] adapter name to skip during detection
     # @return [Class] the adapter class
     # @example
-    #   AdapterSelector.default_adapter_excluding(:fast_jsonparser)  #=> MultiJson::Adapters::Oj
+    #   AdapterSelector.default_adapter_excluding(:fast_jsonparser)  #=> MultiJSON::Adapters::Oj
     def default_adapter_excluding(excluded)
       Concurrency.synchronize(:default_adapter) do
         name = loaded_adapter(excluding: excluded)
@@ -131,7 +151,7 @@ module MultiJson
     # @return [void]
     def warn_about_fallback
       Kernel.warn(
-        "[WARNING] MultiJson is falling back to the json_gem adapter " \
+        "[WARNING] MultiJSON is falling back to the json_gem adapter " \
         "because no other JSON library could be loaded."
       )
     end
@@ -169,7 +189,7 @@ module MultiJson
       require_relative "adapters/#{normalized}"
 
       class_name = normalized.split("_").map(&:capitalize).join
-      ::MultiJson::Adapters.const_get(class_name)
+      ::MultiJSON::Adapters.const_get(class_name)
     end
 
     # Validate that an adapter satisfies the documented contract
@@ -187,7 +207,7 @@ module MultiJson
       raise AdapterError, "Adapter #{adapter} must respond to .load" unless adapter.respond_to?(:load)
       raise AdapterError, "Adapter #{adapter} must respond to .dump" unless adapter.respond_to?(:dump)
 
-      MultiJson.parse_error_class_for(adapter)
+      MultiJSON.parse_error_class_for(adapter)
       adapter
     end
   end

data/lib/multi_json/adapters/fast_jsonparser.rb

@@ -4,13 +4,13 @@ require "fast_jsonparser"
 require_relative "../adapter"
 require_relative "../adapter_selector"
 
-module MultiJson
+module MultiJSON
   module Adapters
     # Use the FastJsonparser library to load, and the fastest other
     # available adapter to dump.
     #
     # FastJsonparser only implements parsing, so the ``dump`` side of
-    # the adapter is delegated to whichever adapter MultiJson would
+    # the adapter is delegated to whichever adapter MultiJSON would
     # pick if FastJsonparser weren't installed (oj → yajl → jr_jackson
     # → json_gem → gson). The delegate is resolved lazily at the first
     # ``dump`` call, not at file load time, so load order doesn't lock
@@ -18,7 +18,7 @@ module MultiJson
     # the first ``dump`` call (typical applications already have ``oj``
     # loaded by then).
     class FastJsonparser < Adapter
-      defaults :load, symbolize_keys: false
+      defaults :load, symbolize_names: false
 
       # Exception raised when JSON parsing fails
       ParseError = ::FastJsonparser::ParseError
@@ -43,8 +43,8 @@ module MultiJson
         # @api private
         # @return [Class] delegate adapter class
         def dump_delegate
-          MultiJson::Concurrency.synchronize(:dump_delegate) do
-            @dump_delegate ||= MultiJson::AdapterSelector.default_adapter_excluding(:fast_jsonparser)
+          MultiJSON::Concurrency.synchronize(:dump_delegate) do
+            @dump_delegate ||= MultiJSON::AdapterSelector.default_adapter_excluding(:fast_jsonparser)
           end
         end
       end
@@ -53,19 +53,21 @@ module MultiJson
       #
       # FastJsonparser.parse only accepts ``symbolize_keys`` and raises
       # on unknown keyword arguments, so the adapter explicitly forwards
-      # only that option and silently drops the rest. Pass other options
-      # through ``MultiJson.load_options=`` and they'll apply to whichever
-      # adapter MultiJson selects when fast_jsonparser isn't installed.
+      # MultiJSON's canonical ``:symbolize_names`` option as
+      # FastJsonparser's native ``symbolize_keys:`` kwarg and silently
+      # drops the rest. Pass other options through
+      # ``MultiJSON.parse_options=`` and they'll apply to whichever
+      # adapter MultiJSON selects when fast_jsonparser isn't installed.
       #
       # @api private
       # @param string [String] JSON string to parse
-      # @param options [Hash] parsing options (only :symbolize_keys is honored)
+      # @param options [Hash] parsing options (only :symbolize_names is honored)
       # @return [Object] parsed Ruby object
       #
       # @example Parse JSON string
       #   adapter.load('{"key":"value"}') #=> {"key" => "value"}
       def load(string, options = {})
-        ::FastJsonparser.parse(string, symbolize_keys: options[:symbolize_keys])
+        ::FastJsonparser.parse(string, symbolize_keys: options[:symbolize_names])
       end
     end
   end

data/lib/multi_json/adapters/json_gem.rb

@@ -3,7 +3,7 @@
 require_relative "../adapter"
 require "json"
 
-module MultiJson
+module MultiJSON
   module Adapters
     # Use the JSON gem to dump/load.
     class JsonGem < Adapter
@@ -44,7 +44,7 @@ module MultiJson
           raise ::JSON::ParserError, "Invalid UTF-8 byte sequence in JSON input" unless string.valid_encoding?
         end
 
-        ::JSON.parse(string, translate_load_options(options))
+        ::JSON.parse(string, options)
       end
 
       # Serialize a Ruby object to JSON
@@ -67,23 +67,6 @@ module MultiJson
 
         ::JSON.pretty_generate(json_object, PRETTY_STATE_PROTOTYPE.merge(options.except(:pretty)))
       end
-
-      private
-
-      # Translate ``:symbolize_keys`` into JSON gem's ``:symbolize_names``
-      #
-      # Returns a new hash without mutating the input. ``options`` is the
-      # cached hash returned from {Adapter.merged_load_options}, so in-place
-      # edits would pollute the cache and corrupt subsequent calls.
-      #
-      # @api private
-      # @param options [Hash] merged load options
-      # @return [Hash] options with ``:symbolize_keys`` translated
-      def translate_load_options(options)
-        return options unless options[:symbolize_keys]
-
-        options.except(:symbolize_keys).merge(symbolize_names: true)
-      end
     end
   end
 end

data/lib/multi_json/adapters/oj.rb

@@ -4,7 +4,7 @@ require "oj"
 require_relative "../adapter"
 require_relative "oj_common"
 
-module MultiJson
+module MultiJSON
   # Namespace for JSON adapter implementations
   #
   # Each adapter wraps a specific JSON library and provides a consistent
@@ -14,7 +14,7 @@ module MultiJson
     class Oj < Adapter
       include OjCommon
 
-      defaults :load, mode: :strict, symbolize_keys: false
+      defaults :load, mode: :strict, symbolize_names: false
       defaults :dump, mode: :compat, time_format: :ruby, use_to_json: true
 
       # In certain cases the Oj gem may throw a ``JSON::ParserError``
@@ -69,10 +69,10 @@ module MultiJson
 
       private
 
-      # Translate ``:symbolize_keys`` into Oj's ``:symbol_keys``
+      # Translate ``:symbolize_names`` into Oj's ``:symbol_keys``
       #
       # Returns a new hash without mutating the input.
-      # ``:symbol_keys`` is always set (true or false) so MultiJson's
+      # ``:symbol_keys`` is always set (true or false) so MultiJSON's
       # behavior is independent of any global ``Oj.default_options``
       # the host application may have set. The input is the cached hash
       # returned from {Adapter.merged_load_options}, so in-place edits
@@ -80,9 +80,9 @@ module MultiJson
       #
       # @api private
       # @param options [Hash] merged load options
-      # @return [Hash] options with ``:symbolize_keys`` translated
+      # @return [Hash] options with ``:symbolize_names`` translated
       def translate_load_options(options)
-        options.except(:symbolize_keys).merge(symbol_keys: options[:symbolize_keys] == true)
+        options.except(:symbolize_names).merge(symbol_keys: options[:symbolize_names] == true)
       end
     end
   end

data/lib/multi_json/adapters/oj_common.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module MultiJson
+module MultiJSON
   module Adapters
     # Shared functionality for the Oj adapter
     #

data/lib/multi_json/adapters/yajl.rb

@@ -3,7 +3,7 @@
 require "yajl"
 require_relative "../adapter"
 
-module MultiJson
+module MultiJSON
   module Adapters
     # Use the Yajl-Ruby library to dump/load.
     class Yajl < Adapter