otoindiff 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3ca434647f9c7853413d2a3cd0fd2965b763bfd50c404f583af67a98651b47b
-  data.tar.gz: 9a3bde8b5cbe13efc52f585b77e5bad3a57ab1dc13eae88700a162238c5c986f
+  metadata.gz: 1aabb24819d8d4ac57b6694ac105527a9a9cf4b8faff156130928a635e288a91
+  data.tar.gz: 6c7bc3fbb207a33667448fb2af8223ab1562a00895f0940fca148cc12edfd92d
 SHA512:
-  metadata.gz: a2bae63aaa05d12a3bac9e30df8e91f98e3e871fa0d445ccb6804c8f94b5c3c4453eacfbccac675983ac29d71ef4e0a71878eb2a543e105c45e00a5d7f6c1f63
-  data.tar.gz: 983e9a7ccefdff0be3b9ff135a13c1a6df970c0ce1c00c5ea31e4b5a35cda5597e77aad7395ea145b5946ffe571ffcb5c097669eeb2c7e1010874efe10dd7021
+  metadata.gz: c370cca113c9e7e0120a866dcfbc9ce92637488d06338c0623bccb7ddbfe58a9afd8af1d7e31bb0e598fb2585053263beb820d3acf7571608966e47e00a910a6
+  data.tar.gz: 6c16fa6b2b110ea8ab20475fa6c1ddd5c81e5da003d2a6be201cf63e43fc301bc94d779c70b44f0f744ffa62d25eb8fcdf99046bd943860b8a2913f5fc4ad922

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## [Unreleased]
 
+## [0.2.1] - 2026-10-15
+
+- Fix `dig` raising `NoMethodError` instead of Ruby's `TypeError` when the path
+  continues past a value that has no `#dig` (e.g. `{ a: 1 }.dig(:a, :x)`), both
+  globally and under `using Otoindiff::Disabled`.
+
+## [0.2.0] - 2026-10-15
+
+- Add `Otoindiff::Disabled` refinement to opt a single class out of indifferent
+  access (`using Otoindiff::Disabled`) while the rest of the code base keeps it.
+- Fix i18n lookups always returning "Translation missing": hashes with a default proc
+  (such as the i18n backend's translations store) now receive the caller's key instead
+  of a converted one, so entries are no longer stored under the wrong key type.
+- Fix `fetch` with a default value or block ignoring a key stored as the other type
+  (`{ foo: 1 }.fetch('foo', 0)` now returns `1`).
+- Fix `dig` returning `nil` when traversing into arrays or other non-Hash objects.
+- Fix `false` values being returned as `nil` when accessed with the other key type.
+
 ## [0.1.0] - 2024-12-12
 
 - Initial release

data/README.md

@@ -15,3 +15,35 @@ Add this line to your application's Gemfile:
 ```ruby
 gem 'otoindiff'
 ```
+
+## Usage
+
+Requiring the gem enables indifferent access for every `Hash`:
+
+```ruby
+hash = { foo: 'bar', 'baz' => 'qux' }
+hash['foo']        # => "bar"
+hash[:baz]         # => "qux"
+hash.fetch('foo')  # => "bar"
+hash.dig('foo')    # => "bar"
+```
+
+### Opting a class out
+
+To keep plain Hash behaviour in a single class, activate the
+`Otoindiff::Disabled` refinement inside it. The rest of the code base stays
+indifferent:
+
+```ruby
+class StrictParser
+  using Otoindiff::Disabled
+
+  def call(hash)
+    hash['foo']  # => nil for { foo: 'bar' }; only the String key matches
+  end
+end
+```
+
+Refinements are lexical: they apply to `[]`, `fetch` and `dig` calls written
+inside that class body, not to hashes the class hands to other code.
+

data/Rakefile

@@ -5,4 +5,12 @@ require 'minitest/test_task'
 
 Minitest::TestTask.create
 
+namespace :benchmark do
+  desc 'Run benchmarks'
+  task :run do
+    puts 'Running benchmarks...'
+    system('ruby benchmarks/benchmark.rb')
+  end
+end
+
 task default: :test

data/bin/benchmark

@@ -0,0 +1,9 @@
+
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+puts 'Running benchmarks...'
+system('ruby benchmarks/benchmark.rb')
+

data/lib/otoindiff/disabled.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Otoindiff
+  # Refinement that restores plain Hash key access where it is activated.
+  #
+  # otoindiff is enabled globally on require. Activate this refinement in a
+  # class (or file) that needs strict String/Symbol key distinction; Hash calls
+  # written lexically inside it bypass the indifferent lookup.
+  #
+  # @example Opt a single class out
+  #   class StrictParser
+  #     using Otoindiff::Disabled
+  #
+  #     def call(hash)
+  #       hash['foo']  # only matches the String key 'foo'
+  #     end
+  #   end
+  module Disabled
+    refine Hash do
+      def [](key)
+        original_brackets(key)
+      end
+
+      def fetch(key, *args, &block)
+        original_fetch(key, *args, &block)
+      end
+
+      # Native #dig (on Hash, Array, Struct) dispatches to the globally patched
+      # Hash#dig of nested hashes, so walk the path one key at a time to keep
+      # every level strict.
+      def dig(key, *rest)
+        [key, *rest].reduce(self) do |current, k|
+          break nil if current.nil?
+
+          next current.original_brackets(k) if current.is_a?(Hash)
+          raise TypeError, "#{current.class} does not have #dig method" unless current.respond_to?(:dig)
+
+          current.dig(k)
+        end
+      end
+    end
+  end
+end

data/lib/otoindiff/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Otoindiff
-  VERSION = '0.1.0'
+  VERSION = '0.2.1'
 end

data/lib/otoindiff.rb

@@ -2,9 +2,6 @@
 
 require_relative 'otoindiff/version'
 
-require 'active_support'
-require 'active_support/core_ext/hash/indifferent_access'
-
 # Extends Ruby's Hash class with more flexible key access methods
 #
 # This extension provides enhanced hash key lookup capabilities:
@@ -27,33 +24,22 @@ class Hash
   # Retrieve a hash value with flexible key type conversion
   #
   # @param key [Object] The key to retrieve
-  # @return [Object, nil] The value associated with the key, or nil if not found
+  # @return [Object, nil] The value associated with the key, or the hash's default if not found
   def [](key)
-    return original_brackets(key) if key?(key)
-
-    if key.is_a?(String) || key.is_a?(Symbol)
-      original_brackets(key.to_s) || original_brackets(key.to_sym)
-    else
-      original_brackets(key)
-    end
+    original_brackets(otoindiff_key(key))
   end
 
   # Dig into a nested hash with flexible key type conversion
   #
-  # @param keys [Array<Object>] Path of keys to traverse
+  # @param key [Object] The first key to retrieve
+  # @param rest [Array<Object>] Remaining path of keys, passed on to the nested object's #dig
   # @return [Object, nil] The nested value, or nil if path is invalid
-  def dig(*keys)
-    keys.reduce(self) do |current, key|
-      break nil unless current.is_a?(Hash)
+  def dig(key, *rest)
+    value = self[key]
+    return value if rest.empty? || value.nil?
+    raise TypeError, "#{value.class} does not have #dig method" unless value.respond_to?(:dig)
 
-      if key.is_a?(String) || key.is_a?(Symbol)
-        current.original_brackets(key) ||
-          current.original_brackets(key.to_s) ||
-          current.original_brackets(key.to_sym)
-      else
-        current.original_brackets(key)
-      end
-    end
+    value.dig(*rest)
   end
 
   # Fetch a hash value with flexible key type conversion and error handling
@@ -63,16 +49,22 @@ class Hash
   # @return [Object] The value associated with the key
   # @raise [KeyError] If key is not found and no default is provided
   def fetch(key, *args, &block)
-    return original_fetch(key, *args, &block) if key?(key)
+    original_fetch(otoindiff_key(key), *args, &block)
+  end
 
-    if key.is_a?(String) || key.is_a?(Symbol)
-      begin
-        original_fetch(key.to_s, *args, &block)
-      rescue KeyError
-        original_fetch(key.to_sym, *args, &block)
-      end
-    else
-      original_fetch(key, *args, &block)
-    end
+  private
+
+  # Resolve a String/Symbol key to whichever form is actually stored.
+  # Falls back to the caller's key so defaults and default procs receive it unchanged.
+  def otoindiff_key(key)
+    return key if key?(key)
+
+    alt = case key
+          when String then key.to_sym
+          when Symbol then key.to_s
+          end
+    alt && key?(alt) ? alt : key
   end
 end
+
+require_relative 'otoindiff/disabled'

data/sig/otoindiff.rbs

@@ -1,6 +1,10 @@
 module Otoindiff
   VERSION: String
 
+  # Refinement restoring plain Hash key access where activated with `using`
+  module Disabled
+  end
+
   # Extended methods for Hash class with flexible key access
   module HashExtensions
     # Retrieve a value with flexible key type conversion

metadata

@@ -1,29 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: otoindiff
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - bugloper
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-12 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '8.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '8.0'
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
 description: The otoindiff gem modifies all Ruby Hash objects to support indifferent
   access by default, allowing seamless use of string or symbol keys interchangeably.
 email:
@@ -35,11 +20,13 @@ files:
 - CHANGELOG.md
 - README.md
 - Rakefile
-- benchmarks/oto_benchmarks.rb
+- benchmarks/benchmark.rb
+- bin/benchmark
 - bin/console
 - bin/release
 - bin/setup
 - lib/otoindiff.rb
+- lib/otoindiff/disabled.rb
 - lib/otoindiff/version.rb
 - sig/otoindiff.rbs
 homepage: https://github.com/bugloper/otoindiff
@@ -50,7 +37,6 @@ metadata:
   source_code_uri: https://github.com/bugloper/otoindiff
   changelog_uri: https://github.com/bugloper/otoindiff/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'false'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -65,8 +51,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Enhances Ruby hashes with default indifferent access.
 test_files: []