Add benchmark and use single shared Proc instance

Author: guille-work

benchmark/indifferent_bench.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'benchmark/ips'
+require 'hash_kit'
+
+helper = HashKit::Helper.new
+
+# ---------------------------------------------------------------------------
+# Hash builders – every benchmark iteration gets a fresh hash so that
+# default_proc assignment is always exercised (no short-circuit).
+# ---------------------------------------------------------------------------
+
+def build_small_flat_hash
+  { 'name' => 'Alice', 'age' => 30, 'active' => true }
+end
+
+def build_large_flat_hash(n = 100)
+  (0...n).each_with_object({}) { |i, h| h["key_#{i}"] = "value_#{i}" }
+end
+
+def build_nested_hash(depth = 5)
+  hash = { 'leaf' => 'value' }
+  depth.times { |i| hash = { "level_#{i}" => hash, "sibling_#{i}" => 'data' } }
+  hash
+end
+
+def build_hash_with_arrays
+  {
+    'users' => [
+      { 'name' => 'Alice', 'roles' => [{ 'id' => 1, 'name' => 'admin' }] },
+      { 'name' => 'Bob',   'roles' => [{ 'id' => 2, 'name' => 'editor' }] },
+      { 'name' => 'Carol', 'roles' => [{ 'id' => 3, 'name' => 'viewer' }] }
+    ],
+    'meta' => { 'page' => 1, 'total' => 3 }
+  }
+end
+
+def build_large_nested_hash(width = 20, depth = 4)
+  return (0...width).each_with_object({}) { |i, h| h["key_#{i}"] = "val_#{i}" } if depth == 0
+
+  (0...width).each_with_object({}) do |i, h|
+    h["node_#{i}"] = build_large_nested_hash(width, depth - 1)
+  end
+end
+
+# ---------------------------------------------------------------------------
+# Benchmark suite
+# ---------------------------------------------------------------------------
+
+puts 'HashKit::Helper#indifferent! benchmark'
+puts "Ruby #{RUBY_VERSION} / benchmark-ips #{Benchmark::IPS::VERSION}"
+puts '=' * 60
+
+Benchmark.ips do |x|
+  x.config(warmup: 2, time: 5)
+
+  # --- Scenario 1: small flat hash (3 keys) ---
+  x.report('small flat hash (3 keys)') do
+    helper.indifferent!(build_small_flat_hash)
+  end
+
+  # --- Scenario 2: large flat hash (100 keys) ---
+  x.report('large flat hash (100 keys)') do
+    helper.indifferent!(build_large_flat_hash(100))
+  end
+
+  # --- Scenario 3: deeply nested hash (5 levels) ---
+  x.report('nested hash (depth=5)') do
+    helper.indifferent!(build_nested_hash(5))
+  end
+
+  # --- Scenario 4: hash containing arrays of hashes ---
+  x.report('hash with arrays') do
+    helper.indifferent!(build_hash_with_arrays)
+  end
+
+  # --- Scenario 5: large nested hash (wide + deep) ---
+  x.report('large nested (10x3)') do
+    helper.indifferent!(build_large_nested_hash(10, 3))
+  end
+
+  # --- Scenario 6: many sequential calls on small hashes ---
+  x.report('50x sequential small hashes') do
+    50.times { helper.indifferent!(build_small_flat_hash) }
+  end
+
+  # --- Scenario 7: many sequential calls on medium hashes ---
+  x.report('50x sequential nested hashes') do
+    50.times { helper.indifferent!(build_nested_hash(3)) }
+  end
+
+  x.compare!
+end

hash_kit.gemspec

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'hash_kit/version'
 
@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_development_dependency 'benchmark-ips', '~> 2.0'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'rake'

lib/hash_kit/helper.rb

@@ -3,22 +3,24 @@
 module HashKit
   # Hash kit Helper class
   class Helper
+    INDIFFERENT_PROC = proc do |h, k|
+      if h.key?(k.to_s)
+        h[k.to_s]
+      elsif h.key?(k.to_sym)
+        h[k.to_sym]
+      else
+        nil
+      end
+    end
+
     # This method is called to make a hash allow indifferent access (it will
     # accept both strings & symbols for a valid key).
     def indifferent!(hash)
       return unless hash.is_a?(Hash)
 
       # Set the default proc to allow the key to be either string or symbol if
       # a matching key is found.
-      hash.default_proc = proc do |h, k|
-        if h.key?(k.to_s)
-          h[k.to_s]
-        elsif h.key?(k.to_sym)
-          h[k.to_sym]
-        else
-          nil
-        end
-      end
+      hash.default_proc = INDIFFERENT_PROC
 
       # Recursively process any child hashes
       hash.each do |key,value|