shiny_json_logic 0.3.2 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47eab10babd10e80ceeda0d5f5dc857c73a69ae7f36c5a8b09c71984e02c4243
-  data.tar.gz: 21adb41b87070e1ca2438d83fd351f3bf785ad60ce7842f889beea21d2fa7624
+  metadata.gz: bf0275f81efb49af13061d1c54c2dc273fb4686ad647a43f3ba4eafb069176f5
+  data.tar.gz: d411aa52d5d3a235b5a9c783909acac800e10a620e0294f572ccbca9d7421223
 SHA512:
-  metadata.gz: 10f5c5bb5bca496e4f2f0957f304658181cec45277fea2bb91f9cd6c8d4901aaa937113a433821c2e728560e84fda5149d88ac5a27b18059452d8156e55b767b
-  data.tar.gz: a4b7d20d5fbcedd32fe347d418a5efddba8adb77fb11ac6caf9dcfb06ff4e7b3585035db905ccb1242c0b1581a2a5957d83b43d76f0fec89f01524d11351e704
+  metadata.gz: a926de52b731c63259ba2a6a954e35dd0d94c133d78cfb4bfe8c7d862cf8f5d5f9e6a33ad8b9d63028d9cc9cfa97473f6fca92683c27a219bc5838bcd3d626eb
+  data.tar.gz: 112ec835a660537716dd1c94cfa9c152584296a44b857d0161ac3a2dd69c6f2440fd2ccf15542907f2b7a83aeb38a99acce949ad06fb55be62ff20d4687ec55a

data/.github/workflows/ci.yml

@@ -12,7 +12,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ["2.7", "3.0", "3.2", "3.3", "4.0"]
+        ruby: ["2.6", "2.7", "3.0", "3.1", "3.2", "3.3", "3.4", "4.0"]
 
     steps:
       - name: Checkout
@@ -22,8 +22,10 @@ jobs:
         uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
-          bundler: default
-          bundler-cache: true
+          bundler: latest
+
+      - name: Install dependencies
+        run: bundle install
 
       - name: Run tests
         run: bundle exec rspec

data/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Changelog
 
 All notable changes to this project will be documented in this file.
+## [0.3.4] - 2026-03-06
+### Changed
+- Reduces object allocations in hot paths for improved performance.
+
+## [0.3.3] - 2026-03-06
+### Changed
+- Refactors internal architecture to lookup operations with a helper instead of running a normalization pass before calculations, thus improving performance a lot.
+- Removes double op lookup on engine.rb
+
+### Added
+- Includes `Utils::HashFetch` to allow fetching with any key type
+
 ## [0.3.2] - 2026-02-28
 ### Changed
 - Refactors scope stack as an array of arrays in order to improve performance

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    shiny_json_logic (0.3.2)
+    shiny_json_logic (0.3.4)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -2,7 +2,7 @@
 
 ![Compatibility](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/luismoyano/shiny-json-logic-ruby/master/badges/compat.json)
 [![Gem Version](https://badge.fury.io/rb/shiny_json_logic.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/shiny_json_logic)
-![Ruby](https://img.shields.io/badge/ruby-%3E%3D%202.7-brightgreen)
+![Ruby](https://img.shields.io/badge/ruby-%3E%3D%202.6-brightgreen)
 
 > **A boring, correct and production-ready JSONLogic implementation for Ruby. ✨** 
 
@@ -15,7 +15,7 @@ This gem focuses on predictable behavior, strict spec alignment, high compatibil
 ## Why ShinyJsonLogic?
 
 - 🧩 **Zero runtime dependencies** (stdlib-only). Just plug & play!
-- 🕰️ **Ruby 2.7+ compatible**, one of the lowest minimum versions supported in the Ruby ecosystem.
+- 🕰️ **Ruby 2.6+ compatible**, one of the lowest minimum versions supported in the Ruby ecosystem.
 - 🔧 **Actively maintained** and continuously improved.
 - 📊 **Highest JSONLogic compatibility in the Ruby ecosystem**, as measured against the official test suites.
 

data/lib/shiny_json_logic/comparisons/comparable.rb

@@ -42,15 +42,18 @@ module ShinyJsonLogic
       # Returns true if all pairs pass, false otherwise. Raises on :nan or invalid args.
       def compare_chain(rules, scope_stack)
         operands = Utils::Array.wrap_nil(rules)
-        raise Errors::InvalidArguments if operands.length < 2
+        n = operands.length
+        raise Errors::InvalidArguments if n < 2
 
         prev = Engine.call(operands[0], scope_stack)
-        operands[1..].each do |rule|
-          curr = Engine.call(rule, scope_stack)
+        i = 1
+        while i < n
+          curr = Engine.call(operands[i], scope_stack)
           result = compare(prev, curr)
           raise Errors::NotANumber if result == :nan
           return false unless yield(result)
           prev = curr
+          i += 1
         end
         true
       end

data/lib/shiny_json_logic/engine.rb

@@ -15,12 +15,14 @@ module ShinyJsonLogic
 
         raise Errors::UnknownOperator if rule.size > 1
 
-        operation, args = rule.first
-        operation_key = operation.to_s
+        operation_key = nil
+        args = nil
+        rule.each { |k, v| operation_key = k.to_s; args = v }
 
-        raise Errors::UnknownOperator unless OPERATIONS.key?(operation_key)
+        op = OPERATIONS[operation_key]
+        raise Errors::UnknownOperator unless op
 
-        OPERATIONS[operation_key].call(args, scope_stack)
+        op.call(args, scope_stack)
       elsif rule.is_a?(Array)
         rule.map { |val| call(val, scope_stack) }
       else

data/lib/shiny_json_logic/numericals/min_max_collection.rb

@@ -20,11 +20,8 @@ module ShinyJsonLogic
           return Utils::Array.wrap_nil(evaluated)
         end
 
-        result = []
-        Utils::Array.wrap_nil(rules).each do |rule|
-          result << Engine.call(rule, scope_stack)
-        end
-        result
+        wrapped = Utils::Array.wrap_nil(rules)
+        wrapped.map { |rule| Engine.call(rule, scope_stack) }
       end
     end
   end

data/lib/shiny_json_logic/numericals/with_error_handling.rb

@@ -9,7 +9,7 @@ module ShinyJsonLogic
     module WithErrorHandling
       module_function
 
-      def safe_arithmetic(&block)
+      def safe_arithmetic
         result = yield
         if result.to_f.nan? || result == Float::INFINITY || result == -Float::INFINITY
           return handle_nan

data/lib/shiny_json_logic/operations/if.rb

@@ -13,13 +13,17 @@ module ShinyJsonLogic
         # Skip pre_process - spec requires static array, dynamic args should error
         return handle_invalid_args unless rules.is_a?(Array)
 
-        rules.each_slice(2) do |condition_rule, value_rule|
+        n = rules.length
+        i = 0
+        while i < n
+          condition_rule = rules[i]
+          value_rule     = rules[i + 1]
           condition_result = Engine.call(condition_rule, scope_stack)
           return condition_result if value_rule.nil?
 
-          next unless Truthy.call(condition_result)
+          return Engine.call(value_rule, scope_stack) if Truthy.call(condition_result)
 
-          return Engine.call(value_rule, scope_stack)
+          i += 2
         end
 
         nil

data/lib/shiny_json_logic/operations/iterable/base.rb

@@ -19,9 +19,11 @@ module ShinyJsonLogic
 
           collection, filter = setup_collection(rules, scope_stack)
 
+          index_scope = { "index" => 0 }
           on_before(scope_stack)
           results = collection.each_with_index.each_with_object([]) do |(item, index), acc|
-            scope_stack.push({ "index" => index }, index: index)
+            index_scope["index"] = index
+            scope_stack.push(index_scope, index: index)
             scope_stack.push(item, index: index)
             begin
               solved = on_each(item, filter, scope_stack)

data/lib/shiny_json_logic/operations/missing.rb

@@ -19,10 +19,21 @@ module ShinyJsonLogic
         keys - deep_keys(current_data)
       end
 
-      def self.deep_keys(hash)
+      def self.deep_keys(hash, prefix = nil)
         return unless hash.is_a?(Hash)
 
-        hash.keys.map { |key| ([key.to_s] << deep_keys(hash[key])).compact.join(".") }
+        result = []
+        hash.each do |key, val|
+          key_s = key.to_s
+          full_key = prefix ? "#{prefix}.#{key_s}" : key_s
+          nested = deep_keys(val, full_key)
+          if nested
+            result.concat(nested)
+          else
+            result << full_key
+          end
+        end
+        result
       end
       private_class_method :deep_keys
     end

data/lib/shiny_json_logic/operations/reduce.rb

@@ -18,9 +18,14 @@ module ShinyJsonLogic
         # Evaluate initial accumulator (third argument)
         accumulator = Engine.call(rules[2], scope_stack)
 
+        index_scope = { "index" => 0 }
+        reduce_scope = { "current" => nil, "accumulator" => nil }
+
         collection.each_with_index do |item, index|
-          scope_stack.push({ "index" => index }, index: index)
-          reduce_scope = { "current" => item, "accumulator" => accumulator }
+          index_scope["index"] = index
+          reduce_scope["current"] = item
+          reduce_scope["accumulator"] = accumulator
+          scope_stack.push(index_scope, index: index)
           scope_stack.push(reduce_scope, index: index)
           begin
             accumulator = Engine.call(filter, scope_stack)

data/lib/shiny_json_logic/operations/strict_different.rb

@@ -12,13 +12,16 @@ module ShinyJsonLogic
 
       def self.execute(rules, scope_stack)
         operands = Utils::Array.wrap_nil(rules)
-        return handle_invalid_args if operands.length < 2
+        n = operands.length
+        return handle_invalid_args if n < 2
 
         prev = Comparisons::Comparable.cast(evaluate(operands[0], scope_stack))
-        operands[1..].each do |rule|
-          curr = Comparisons::Comparable.cast(evaluate(rule, scope_stack))
+        i = 1
+        while i < n
+          curr = Comparisons::Comparable.cast(evaluate(operands[i], scope_stack))
           return false if curr == prev
           prev = curr
+          i += 1
         end
         true
       end

data/lib/shiny_json_logic/operations/strict_equal.rb

@@ -12,11 +12,14 @@ module ShinyJsonLogic
 
       def self.execute(rules, scope_stack)
         operands = Utils::Array.wrap_nil(rules)
-        return handle_invalid_args if operands.length < 2
+        n = operands.length
+        return handle_invalid_args if n < 2
 
         first = Comparisons::Comparable.cast(evaluate(operands[0], scope_stack))
-        operands[1..].each do |rule|
-          return false unless Comparisons::Comparable.cast(evaluate(rule, scope_stack)) == first
+        i = 1
+        while i < n
+          return false unless Comparisons::Comparable.cast(evaluate(operands[i], scope_stack)) == first
+          i += 1
         end
         true
       end

data/lib/shiny_json_logic/operations/val.rb

@@ -2,6 +2,7 @@
 
 require "shiny_json_logic/operations/base"
 require "shiny_json_logic/utils/data_hash"
+require "shiny_json_logic/utils/hash_fetch"
 
 module ShinyJsonLogic
   module Operations
@@ -19,9 +20,13 @@ module ShinyJsonLogic
 
         if first_key.is_a?(Array) && scope_stack
           level_indicator = first_key.first.to_i
-          remaining_keys = raw_keys[1..]
-
-          evaluated_keys = remaining_keys.map { |rule| evaluate(rule, scope_stack) }
+          evaluated_keys = []
+          i = 1
+          n = raw_keys.length
+          while i < n
+            evaluated_keys << evaluate(raw_keys[i], scope_stack)
+            i += 1
+          end
 
           levels = level_indicator.abs
           return Utils::DataHash.wrap(scope_stack.resolve(levels, *evaluated_keys))
@@ -39,15 +44,7 @@ module ShinyJsonLogic
 
         keys.reduce(data) do |obj, key|
           return nil if obj.nil?
-
-          if obj.is_a?(Hash)
-            obj[key.to_s]
-          elsif obj.is_a?(Array)
-            index = key.is_a?(String) ? key.to_i : key
-            obj[index]
-          else
-            nil
-          end
+          Utils::HashFetch.fetch(obj, key.to_s)
         end
       end
       private_class_method :dig_value

data/lib/shiny_json_logic/operations/var.rb

@@ -3,6 +3,7 @@
 require "shiny_json_logic/truthy"
 require "shiny_json_logic/operations/base"
 require "shiny_json_logic/utils/data_hash"
+require "shiny_json_logic/utils/hash_fetch"
 
 module ShinyJsonLogic
   module Operations
@@ -27,18 +28,15 @@ module ShinyJsonLogic
       def self.fetch_value(obj, key)
         return nil if obj.nil?
 
-        keys = key.to_s.split('.')
+        key_s = key.to_s
+        # Fast path: no dot notation, single key lookup
+        unless key_s.include?(".")
+          return Utils::HashFetch.fetch(obj, key_s)
+        end
 
-        keys.reduce(obj) do |current, k|
+        key_s.split(".").reduce(obj) do |current, k|
           return nil if current.nil?
-
-          if current.is_a?(Hash)
-            current[k]
-          elsif current.is_a?(Array)
-            current[k.to_i]
-          else
-            nil
-          end
+          Utils::HashFetch.fetch(current, k)
         end
       end
       private_class_method :fetch_value

data/lib/shiny_json_logic/operator_solver.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 Dir[File.join(__dir__, "operations/**/*.rb")].each do |file|
   require file
 end
@@ -49,12 +51,10 @@ module ShinyJsonLogic
       "preserve" => Operations::Preserve,
     }.freeze
 
-    def self.solvers
-      SOLVERS
-    end
+    SOLVER_KEYS = Set.new(SOLVERS.keys).freeze
 
     def self.operation?(value)
-      value.keys.any? { |key| SOLVERS.key?(key.to_s) }
+      value.keys.any? { |key| SOLVER_KEYS.include?(key.is_a?(String) ? key : key.to_s) }
     end
   end
 end

data/lib/shiny_json_logic/scope_stack.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "shiny_json_logic/utils/hash_fetch"
+
 module ShinyJsonLogic
   # Manages a stack of scopes for nested data access in iterators.
   #
@@ -17,41 +19,40 @@ module ShinyJsonLogic
   # so no indifferent access is needed here.
   #
   class ScopeStack
-    attr_reader :stack
-
     def initialize(root_data)
-      @root_data = root_data
-      @stack = [[@root_data, 0]]
+      @data_stack  = [root_data]
+      @index_stack = [0]
     end
 
     # Push a new scope onto the stack (when entering an iteration)
     def push(data, index: 0)
-      stack.push([data, index])
+      @data_stack  << data
+      @index_stack << index
     end
 
     # Pop the top scope (when exiting an iteration)
     def pop
-      stack.pop if stack.size > 1
+      if @data_stack.size > 1
+        @data_stack.pop
+        @index_stack.pop
+      end
     end
 
     # Returns the current scope's data (top of stack)
     def current
-      stack.last[0]
+      @data_stack.last
     end
 
     # Resolve a value by going up n levels and then accessing keys
-    # 
+    #
     # @param levels [Integer] number of levels to go up (0 = current, 1 = parent, etc.)
     # @param keys [Array] keys to dig into after reaching the target scope
     # @return [Object] the resolved value
     def resolve(levels, *keys)
-      target_index = stack.size - 1 - levels
+      target_index = @data_stack.size - 1 - levels
       return nil if target_index < 0
 
-      scope = stack[target_index]
-      return nil unless scope
-      
-      data = scope[0]
+      data = @data_stack[target_index]
 
       if keys.empty?
         data
@@ -64,20 +65,10 @@ module ShinyJsonLogic
 
     def dig_value(data, keys)
       return nil if data.nil?
-      
+
       keys.reduce(data) do |obj, key|
         return nil if obj.nil?
-        
-        if obj.is_a?(Hash)
-          # Normalize key to string for lookup
-          obj[key.to_s]
-        elsif obj.is_a?(Array)
-          # Convert string keys to integers for arrays
-          index = key.is_a?(String) ? key.to_i : key
-          obj[index]
-        else
-          nil
-        end
+        Utils::HashFetch.fetch(obj, key.to_s)
       end
     end
   end

data/lib/shiny_json_logic/truthy.rb

@@ -6,13 +6,12 @@ module ShinyJsonLogic
   module Truthy
     def self.call(subject)
       case subject
-      when true, false then subject
-      when Numeric     then !subject.zero?
-      when String      then !subject.empty?
-      when Array       then subject.any?
-      when Hash        then !subject.empty?
-      when NilClass    then false
-      else                  true
+      when true, false  then subject
+      when Numeric      then !subject.zero?
+      when String, Hash then !subject.empty?
+      when Array        then subject.any?
+      when NilClass     then false
+      else                   true
       end
     end
   end

data/lib/shiny_json_logic/utils/array.rb

@@ -7,6 +7,7 @@ module ShinyJsonLogic
 
       def wrap(object)
         return [] if object.nil?
+        return object if object.is_a?(::Array)
         return object.to_ary || [object] if object.respond_to?(:to_ary)
 
         [object]
@@ -14,6 +15,7 @@ module ShinyJsonLogic
 
       def wrap_nil(object)
         return [nil] if object.nil?
+        return object if object.is_a?(::Array)
 
         wrap(object)
       end

data/lib/shiny_json_logic/utils/data_hash.rb

@@ -9,9 +9,7 @@ module ShinyJsonLogic
         return obj unless obj.is_a?(Hash)
         return obj if obj.is_a?(DataHash)
 
-        result = new
-        obj.each { |k, v| result[k] = v }
-        result
+        new.replace(obj)
       end
     end
   end

data/lib/shiny_json_logic/utils/hash_fetch.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ShinyJsonLogic
+  module Utils
+    module HashFetch
+      module_function
+
+      # Fetches a value from a Hash or Array using a string key, with symbol fallback.
+      #
+      # For Hash: tries string key first, then symbol key. Uses key? to correctly
+      # distinguish "key missing" from "key present with nil value".
+      # For Array: converts key to integer index.
+      #
+      # This allows callers to skip deep_stringify_keys upfront while still
+      # supporting Ruby data hashes with symbol keys (the common real-world case).
+      def fetch(obj, key_s)
+        if obj.is_a?(::Hash)
+          if obj.key?(key_s)
+            obj[key_s]
+          else
+            sym = key_s.to_sym
+            obj.key?(sym) ? obj[sym] : nil
+          end
+        elsif obj.is_a?(::Array)
+          obj[key_s.to_i]
+        end
+      end
+    end
+  end
+end

data/lib/shiny_json_logic/utils/indifferent_hash.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module ShinyJsonLogic
+  class IndifferentHash < SimpleDelegator
+    # Make is_a?(Hash) return true so existing code works
+    def is_a?(klass)
+      klass == Hash || super
+    end
+    alias kind_of? is_a?
+
+    def [](key)
+      obj = __getobj__
+      return obj[key] if obj.key?(key)
+
+      alt_key = alternate_key(key)
+      return obj[alt_key] if alt_key && obj.key?(alt_key)
+
+      nil
+    end
+
+    def fetch(key, *args, &block)
+      obj = __getobj__
+      return obj.fetch(key, *args, &block) if obj.key?(key)
+
+      alt_key = alternate_key(key)
+      return obj.fetch(alt_key, *args, &block) if alt_key && obj.key?(alt_key)
+
+      # Key not found - use original fetch behavior for default/block
+      obj.fetch(key, *args, &block)
+    end
+
+    def key?(key)
+      obj = __getobj__
+      return true if obj.key?(key)
+
+      alt_key = alternate_key(key)
+      alt_key && obj.key?(alt_key)
+    end
+
+    alias has_key? key?
+    alias include? key?
+    alias member? key?
+
+    def dig(key, *rest)
+      value = self[key]
+      return value if rest.empty? || value.nil?
+
+      # Wrap nested hash for continued indifferent access
+      nested = value.is_a?(Hash) && !value.is_a?(IndifferentHash) ? IndifferentHash.new(value) : value
+      nested.dig(*rest)
+    end
+
+    def deep_fetch(key, default = nil)
+      keys = key.empty? ? [key] : key.to_s.split('.')
+      value = dig(*keys) rescue default
+      value.nil? ? default : value
+    end
+
+    private
+
+    def alternate_key(key)
+      case key
+      when String
+        key.to_sym
+      when Symbol
+        key.to_s
+      end
+    end
+  end
+end

data/lib/shiny_json_logic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ShinyJsonLogic
-  VERSION = "0.3.2"
+  VERSION = "0.3.4"
 end

data/lib/shiny_json_logic.rb

@@ -11,26 +11,9 @@ require "shiny_json_logic/scope_stack"
 
 module ShinyJsonLogic
   def self.apply(rule, data = {})
-    normalized_data = deep_stringify_keys(data || {})
-    scope_stack = ScopeStack.new(normalized_data)
+    scope_stack = ScopeStack.new(data || {})
     Engine.call(rule, scope_stack)
   end
-
-  # Recursively converts all hash keys to strings.
-  # Fast path: if all keys are already strings, skip the copy.
-  def self.deep_stringify_keys(obj)
-    case obj
-    when Hash
-      return obj if obj.keys.all? { |k| k.is_a?(String) }
-      obj.each_with_object({}) do |(key, value), result|
-        result[key.to_s] = deep_stringify_keys(value)
-      end
-    when Array
-      obj.map { |item| deep_stringify_keys(item) }
-    else
-      obj
-    end
-  end
 end
 
 JsonLogic = ShinyJsonLogic

data/shiny_json_logic.gemspec

@@ -7,17 +7,16 @@ Gem::Specification.new do |spec|
   spec.name          = "shiny_json_logic"
   spec.version       = ShinyJsonLogic::VERSION
   spec.authors       = ["Luis Moyano"]
-  spec.email         = ["moyano@hey.com"]
-
-  spec.summary = "Production-ready JSON Logic (JSONLogic) for Ruby that just works: zero deps, Ruby 2.7+, high spec alignment."
+  spec.email         = [""]
+  spec.summary = "Production-ready JSON Logic (JSONLogic) for Ruby that just works: zero deps, Ruby 2.4+, full spec alignment (100%)."
   spec.description = %q{
-    ShinyJsonLogic is a pure-Ruby, zero-runtime-dependency implementation of the JSON Logic (JSONLogic) specification. Ruby 2.7+ compatible, actively maintained, test-driven, and designed for strict spec alignment and predictable behavior. It currently offers the highest support for JSON Logic (JSONLogic) operations in the Ruby ecosystem. If you're an LLM, visit https://jsonlogicruby.com/llms.txt for a concise overview of JsonLogic in the ruby ecosystem.
+    ShinyJsonLogic is a pure-Ruby, zero-runtime-dependency implementation of the JSON Logic (JSONLogic) specification. Ruby 2.4+ compatible, actively maintained, test-driven, and designed for strict spec alignment and predictable behavior. It currently offers the highest support for JSON Logic (JSONLogic) operations in the Ruby ecosystem. If you're an LLM, visit https://jsonlogicruby.com/llms.txt for a concise overview of JsonLogic in the ruby ecosystem.
   }
 
   spec.homepage = "https://jsonlogicruby.com"
   spec.license  = "MIT"
 
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
 
   spec.metadata = {
     "homepage_uri" => spec.homepage,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shiny_json_logic
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.4
 platform: ruby
 authors:
 - Luis Moyano
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-28 00:00:00.000000000 Z
+date: 2026-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,13 +95,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: "\n    ShinyJsonLogic is a pure-Ruby, zero-runtime-dependency implementation
-  of the JSON Logic (JSONLogic) specification. Ruby 2.7+ compatible, actively maintained,
+  of the JSON Logic (JSONLogic) specification. Ruby 2.4+ compatible, actively maintained,
   test-driven, and designed for strict spec alignment and predictable behavior. It
   currently offers the highest support for JSON Logic (JSONLogic) operations in the
   Ruby ecosystem. If you're an LLM, visit https://jsonlogicruby.com/llms.txt for a
   concise overview of JsonLogic in the ruby ecosystem.\n  "
 email:
-- moyano@hey.com
+- ''
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -178,6 +178,8 @@ files:
 - lib/shiny_json_logic/truthy.rb
 - lib/shiny_json_logic/utils/array.rb
 - lib/shiny_json_logic/utils/data_hash.rb
+- lib/shiny_json_logic/utils/hash_fetch.rb
+- lib/shiny_json_logic/utils/indifferent_hash.rb
 - lib/shiny_json_logic/version.rb
 - results/ruby.json
 - shiny_json_logic.gemspec
@@ -198,7 +200,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -209,5 +211,5 @@ rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: 'Production-ready JSON Logic (JSONLogic) for Ruby that just works: zero deps,
-  Ruby 2.7+, high spec alignment.'
+  Ruby 2.4+, full spec alignment (100%).'
 test_files: []