shiny_json_logic 0.3.3 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 763e1776b60f327617c84ae32574996acc7029c1ade284482a839ec9e8590f34
-  data.tar.gz: 7208db5ae0a84a4119d67b2a281651eb40b68daea9aedf9fcc73aa0fbb2ab8db
+  metadata.gz: 1ebe927021766f9f1fd019339cbe471dd9d8102e6639cb2c075eb5bf2cf2618c
+  data.tar.gz: a419046895f9b3cdafe511f8a14d39ba641076dec9b41d9c7ada7b6dafc56a8e
 SHA512:
-  metadata.gz: 924234efc1cf60dc46ecbe8daa9a666ebeaeeef84d015a217d8706ea5860b2b4386755b38d5b97e212e2d3817acab1412daf699a3416fad2622092021df84645
-  data.tar.gz: 70eccfb4595ca8af441d1ebe69a8b06b33f87c779d21619a0d1fcbc6e9ea10cf4d4ea85b3380e8ecdb744237b729a3e838ab470d6128219adbe5ced8c35490ad
+  metadata.gz: efbb1ee13c8fb44f15df4d5ea1d1d6d347fb67e6552059afb54c21b754b1442a4f4b2b4d66b19fbcf804bc28861dbd44e90693797b7badf1d5ecd9adea1a096e
+  data.tar.gz: 0036f2a1623dc4f2fbcd16298aa799412402a2437c7d04aefa3e30b1f0b9f3010b5bf88899f6b98d2a2078416fda7d9047cf683f25a0624d4ecab9cc7df742a8

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 # Changelog
 
 All notable changes to this project will be documented in this file.
+## [0.3.5] - 2026-03-06
+### Changed
+- Reduces object allocations further in hot paths (iterator index tracking, early-exit via throw/catch, inline nil-wrapping, scope push simplification) for an additional ~12–18% throughput improvement over 0.3.4.
+- Symbol values are now coerced to String before comparisons (`==`, `===`, `!=`, `!==`, `<`, `>`, `<=`, `>=`, `in`), so Ruby Symbol data round-trips cleanly through JSONLogic rules.
+
+## [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.

data/Gemfile.lock

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

data/lib/shiny_json_logic/comparisons/comparable.rb

@@ -10,7 +10,8 @@ module ShinyJsonLogic
       module_function
 
       def compare(a, b)
-        return :nan if a.is_a?(Array) || a.is_a?(Hash) || b.is_a?(Array) || b.is_a?(Hash)
+        a = a.to_s if a.is_a?(Symbol)
+        b = b.to_s if b.is_a?(Symbol)
 
         if a.is_a?(String) && b.is_a?(String)
           return a <=> b
@@ -28,29 +29,44 @@ module ShinyJsonLogic
         return 0.0 if value == false
         return 1.0 if value == true
         return 0.0 if value.nil?
-        return value.to_f if value.is_a?(String) && Numericals::Numerify.numeric_string?(value)
+
+        value = value.to_s if value.is_a?(Symbol)
+        return value.to_f if Numericals::Numerify.numeric_string?(value)
+
         nil
       end
 
       # Normalize numeric types for strict equality comparisons (=== semantics).
+      # Also coerces Symbol → String so :foo === "foo" holds.
       def cast(value)
+        value = value.to_s if value.is_a?(Symbol)
         value.is_a?(Numeric) ? value.to_f : value
       end
 
+      def comparable_type?(value)
+        value.is_a?(Numeric) || value.is_a?(String) || value.is_a?(Symbol) || value == true || value == false || value.nil?
+      end
+
       # Shared loop for all chain-comparison operators.
       # Yields the compare result for each consecutive pair; block returns true to continue, false to short-circuit.
       # 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)
+        raise Errors::NotANumber unless comparable_type?(prev)
+
+        i = 1
+        while i < n
+          curr = Engine.call(operands[i], scope_stack)
+          raise Errors::NotANumber unless comparable_type?(curr)
           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,8 +15,9 @@ 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 }
 
         op = OPERATIONS[operation_key]
         raise Errors::UnknownOperator unless op

data/lib/shiny_json_logic/numericals/min_max_collection.rb

@@ -10,7 +10,7 @@ module ShinyJsonLogic
       def collect_numeric_values(rules, scope_stack)
         values = collect_values(rules, scope_stack)
         raise Errors::InvalidArguments if values.empty?
-        raise Errors::InvalidArguments unless values.all? { |v| v.is_a?(Numeric) }
+        values.each { |v| raise Errors::InvalidArguments unless v.is_a?(Numeric) }
         values
       end
 
@@ -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/all.rb

@@ -8,10 +8,12 @@ module ShinyJsonLogic
     class All < Iterable::Base
       raise_on_dynamic_args!
 
-      def self.on_after(results, _scope_stack)
-        return false if results.empty?
+      def self.on_each(_item, filter, scope_stack)
+        throw(:early_return, false) unless Truthy.call(Engine.call(filter, scope_stack))
+      end
 
-        results.all? { |res| Truthy.call(res) }
+      def self.on_after(results, _scope_stack)
+        results.empty? ? false : true
       end
     end
   end

data/lib/shiny_json_logic/operations/base.rb

@@ -14,8 +14,9 @@ module ShinyJsonLogic
 
       def self.resolve_rules(rules, scope_stack)
         dynamic = op?(rules)
-        rules = Engine.call(rules, scope_stack) if dynamic
         raise Errors::InvalidArguments if dynamic && raise_on_dynamic_args?
+
+        return Engine.call(rules, scope_stack) if dynamic
         rules
       end
 
@@ -36,7 +37,9 @@ module ShinyJsonLogic
       end
 
       def self.op?(value)
-        return false unless value.is_a?(Hash) && !value.empty?
+        return false unless value.is_a?(Hash)
+        return false if value.empty?
+
         OperatorSolver.operation?(value)
       end
     end

data/lib/shiny_json_logic/operations/filter.rb

@@ -9,12 +9,19 @@ module ShinyJsonLogic
       raise_on_nil_filter!
       raise_on_dynamic_args!
 
-      def self.on_each(item, filter, scope_stack)
-        Truthy.call(Engine.call(filter, scope_stack)) ? item : nil
-      end
+      def self.call(rules, scope_stack)
+        rules = resolve_rules(rules, scope_stack)
+
+        collection, filter = setup_collection(rules, scope_stack)
 
-      def self.on_after(results, _scope_stack)
-        results.compact
+        collection.each_with_object([]) do |item, acc|
+          scope_stack.push(item)
+          begin
+            acc << item if Truthy.call(Engine.call(filter, scope_stack))
+          ensure
+            scope_stack.pop
+          end
+        end
       end
     end
   end

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/inclusion.rb

@@ -8,7 +8,15 @@ module ShinyJsonLogic
       def self.execute(rules, scope_stack)
         needle = evaluate(rules.first, scope_stack)
         haystack = evaluate(rules.last, scope_stack)
-        haystack.include?(needle)
+
+        # Normalize Symbols to String so :foo matches "foo" and vice-versa
+        needle = needle.to_s if needle.is_a?(Symbol)
+
+        if haystack.is_a?(Array)
+          haystack.any? { |el| (el.is_a?(Symbol) ? el.to_s : el) == needle }
+        else
+          haystack.include?(needle)
+        end
       end
     end
   end

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

@@ -19,22 +19,18 @@ module ShinyJsonLogic
 
           collection, filter = setup_collection(rules, scope_stack)
 
-          on_before(scope_stack)
-          results = collection.each_with_index.each_with_object([]) do |(item, index), acc|
-            scope_stack.push({ "index" => index }, index: index)
-            scope_stack.push(item, index: index)
-            begin
-              solved = on_each(item, filter, scope_stack)
-              acc << solved
-              scope_stack.pop
-              scope_stack.pop
-            rescue => e
-              scope_stack.pop  # item scope
-              scope_stack.pop  # iterator context scope
-              raise e
+          early = catch(:early_return) do
+            results = collection.each_with_object([]) do |item, acc|
+              scope_stack.push(item)
+              begin
+                acc << on_each(item, filter, scope_stack)
+              ensure
+                scope_stack.pop
+              end
             end
+            on_after(results, scope_stack)
           end
-          on_after(results, scope_stack)
+          early
         end
 
         def self.setup_collection(rules, scope_stack)
@@ -50,8 +46,6 @@ module ShinyJsonLogic
           [collection, filter]
         end
 
-        def self.on_before(_scope_stack); end
-
         def self.on_each(_item, filter, scope_stack)
           Engine.call(filter, scope_stack)
         end

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/none.rb

@@ -8,10 +8,12 @@ module ShinyJsonLogic
     class None < Iterable::Base
       raise_on_dynamic_args!
 
-      def self.on_after(results, _scope_stack)
-        return true if results.empty?
+      def self.on_each(_item, filter, scope_stack)
+        throw(:early_return, false) if Truthy.call(Engine.call(filter, scope_stack))
+      end
 
-        results.none? { |res| Truthy.call(res) }
+      def self.on_after(results, _scope_stack)
+        true
       end
     end
   end

data/lib/shiny_json_logic/operations/reduce.rb

@@ -18,18 +18,16 @@ module ShinyJsonLogic
         # Evaluate initial accumulator (third argument)
         accumulator = Engine.call(rules[2], scope_stack)
 
-        collection.each_with_index do |item, index|
-          scope_stack.push({ "index" => index }, index: index)
-          reduce_scope = { "current" => item, "accumulator" => accumulator }
-          scope_stack.push(reduce_scope, index: index)
+        reduce_scope = { "current" => nil, "accumulator" => nil }
+
+        collection.each do |item|
+          reduce_scope["current"] = item
+          reduce_scope["accumulator"] = accumulator
+          scope_stack.push(reduce_scope)
           begin
             accumulator = Engine.call(filter, scope_stack)
+          ensure
             scope_stack.pop
-            scope_stack.pop
-          rescue => e
-            scope_stack.pop
-            scope_stack.pop
-            raise e
           end
         end
 

data/lib/shiny_json_logic/operations/some.rb

@@ -8,8 +8,12 @@ module ShinyJsonLogic
     class Some < Iterable::Base
       raise_on_dynamic_args!
 
+      def self.on_each(_item, filter, scope_stack)
+        throw(:early_return, true) if Truthy.call(Engine.call(filter, scope_stack))
+      end
+
       def self.on_after(results, _scope_stack)
-        results.any? { |res| res == true }
+        false
       end
     end
   end

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

@@ -20,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))

data/lib/shiny_json_logic/operations/var.rb

@@ -9,9 +9,18 @@ module ShinyJsonLogic
   module Operations
     class Var < Base
       def self.execute(rules, scope_stack)
+        # Fast path: simple string key, no default
+        if rules.is_a?(String)
+          current_data = scope_stack.current
+          if rules.empty?
+            return Utils::DataHash.wrap(current_data)
+          end
+          return Utils::DataHash.wrap(fetch_value(current_data, rules))
+        end
+
         items = Utils::Array.wrap_nil(rules)
         key = evaluate(items[0], scope_stack)
-        default = items[1] ? evaluate(items[1], scope_stack) : nil
+        default = items.length > 1 ? evaluate(items[1], scope_stack) : nil
         current_data = scope_stack.current
 
         if key.nil? || key == ""
@@ -28,16 +37,27 @@ module ShinyJsonLogic
       def self.fetch_value(obj, key)
         return nil if obj.nil?
 
-        key_s = key.to_s
-        # Fast path: no dot notation, single key lookup
-        unless key_s.include?(".")
+        key_s = key.is_a?(String) ? key : key.to_s
+
+        # Fast path: no dot notation
+        dot_idx = key_s.index(".")
+        unless dot_idx
           return Utils::HashFetch.fetch(obj, key_s)
         end
 
-        key_s.split(".").reduce(obj) do |current, k|
+        # Dot notation: scan without split
+        current = obj
+        start = 0
+        len = key_s.length
+        while start < len
+          dot_idx = key_s.index(".", start)
+          segment = dot_idx ? key_s[start, dot_idx - start] : key_s[start, len - start]
           return nil if current.nil?
-          Utils::HashFetch.fetch(current, k)
+          current = Utils::HashFetch.fetch(current, segment)
+          break unless dot_idx
+          start = dot_idx + 1
         end
+        current
       end
       private_class_method :fetch_value
     end

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
@@ -7,54 +9,56 @@ end
 module ShinyJsonLogic
   module OperatorSolver
     SOLVERS = {
-      "var" => Operations::Var,
-      "missing" => Operations::Missing,
+      "var"          => Operations::Var,
+      "missing"      => Operations::Missing,
       "missing_some" => Operations::MissingSome,
-      "==" => Operations::Equal,
-      "===" => Operations::StrictEqual,
-      "!=" => Operations::Different,
-      "!==" => Operations::StrictDifferent,
-      ">" => Operations::Greater,
-      ">=" => Operations::GreaterEqual,
-      "<" => Operations::Smaller,
-      "<=" => Operations::SmallerEqual,
-      "!" => Operations::Not,
-      "or" => Operations::Or,
-      "and" => Operations::And,
-      "in" => Operations::Inclusion,
-      "cat" => Operations::Concatenation,
-      "%" => Operations::Modulo,
-      "max" => Operations::Max,
-      "min" => Operations::Min,
-      "+" => Operations::Addition,
-      "*" => Operations::Product,
-      "-" => Operations::Subtraction,
-      "/" => Operations::Division,
-      "substr" => Operations::Substring,
-      "merge" => Operations::Merge,
-      "!!" => Operations::DoubleNot,
-      "val" => Operations::Val,
-      "??" => Operations::Coalesce,
-      "exists" => Operations::Exists,
-      "throw" => Operations::Throw,
-      "try" => Operations::Try,
-      "if" => Operations::If,
-      "?:" => Operations::If,
-      "filter" => Operations::Filter,
-      "map" => Operations::Map,
-      "reduce" => Operations::Reduce,
-      "all" => Operations::All,
-      "none" => Operations::None,
-      "some" => Operations::Some,
-      "preserve" => Operations::Preserve,
+      "=="           => Operations::Equal,
+      "==="          => Operations::StrictEqual,
+      "!="           => Operations::Different,
+      "!=="          => Operations::StrictDifferent,
+      ">"            => Operations::Greater,
+      ">="           => Operations::GreaterEqual,
+      "<"            => Operations::Smaller,
+      "<="           => Operations::SmallerEqual,
+      "!"            => Operations::Not,
+      "or"           => Operations::Or,
+      "and"          => Operations::And,
+      "in"           => Operations::Inclusion,
+      "cat"          => Operations::Concatenation,
+      "%"            => Operations::Modulo,
+      "max"          => Operations::Max,
+      "min"          => Operations::Min,
+      "+"            => Operations::Addition,
+      "*"            => Operations::Product,
+      "-"            => Operations::Subtraction,
+      "/"            => Operations::Division,
+      "substr"       => Operations::Substring,
+      "merge"        => Operations::Merge,
+      "!!"           => Operations::DoubleNot,
+      "val"          => Operations::Val,
+      "??"           => Operations::Coalesce,
+      "exists"       => Operations::Exists,
+      "throw"        => Operations::Throw,
+      "try"          => Operations::Try,
+      "if"           => Operations::If,
+      "?:"           => Operations::If,
+      "filter"       => Operations::Filter,
+      "map"          => Operations::Map,
+      "reduce"       => Operations::Reduce,
+      "all"          => Operations::All,
+      "none"         => Operations::None,
+      "some"         => Operations::Some,
+      "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) }
+      # Rules always have exactly 1 key — use each_key with early return
+      # instead of keys.any? which allocates an Array of keys first
+      value.each_key { |key| return SOLVER_KEYS.include?(key.is_a?(String) ? key : key.to_s) }
+      false
     end
   end
 end
+

data/lib/shiny_json_logic/scope_stack.rb

@@ -19,41 +19,35 @@ 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]
     end
 
     # Push a new scope onto the stack (when entering an iteration)
-    def push(data, index: 0)
-      stack.push([data, index])
+    def push(data)
+      @data_stack << data
     end
 
     # Pop the top scope (when exiting an iteration)
     def pop
-      stack.pop if stack.size > 1
+      @data_stack.pop if @data_stack.size > 1
     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

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,8 +15,10 @@ module ShinyJsonLogic
 
       def wrap_nil(object)
         return [nil] if object.nil?
+        return object if object.is_a?(::Array)
+        return object.to_ary || [object] if object.respond_to?(:to_ary)
 
-        wrap(object)
+        [object]
       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.3"
+  VERSION = "0.3.5"
 end

data/shiny_json_logic.gemspec

@@ -8,15 +8,15 @@ Gem::Specification.new do |spec|
   spec.version       = ShinyJsonLogic::VERSION
   spec.authors       = ["Luis Moyano"]
   spec.email         = [""]
-  spec.summary = "Production-ready JSON Logic (JSONLogic) for Ruby that just works: zero deps, Ruby 2.6+, full spec alignment (100%)."
+  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.6+ 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.6.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
 
   spec.metadata = {
     "homepage_uri" => spec.homepage,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shiny_json_logic
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.5
 platform: ruby
 authors:
 - Luis Moyano
@@ -95,7 +95,7 @@ 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.6+ 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
@@ -179,6 +179,7 @@ files:
 - 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
@@ -199,7 +200,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -210,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.6+, full spec alignment (100%).'
+  Ruby 2.4+, full spec alignment (100%).'
 test_files: []