shiny_json_logic 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ebe927021766f9f1fd019339cbe471dd9d8102e6639cb2c075eb5bf2cf2618c
-  data.tar.gz: a419046895f9b3cdafe511f8a14d39ba641076dec9b41d9c7ada7b6dafc56a8e
+  metadata.gz: cb0d5385d70e0de02275f1a5a4ad0f8d6014c9f8030df64882cb7da1ff44942d
+  data.tar.gz: a608c50e2ef5acb46a348674df1ffeff928274f142f5d71ffbaf1101787b4149
 SHA512:
-  metadata.gz: efbb1ee13c8fb44f15df4d5ea1d1d6d347fb67e6552059afb54c21b754b1442a4f4b2b4d66b19fbcf804bc28861dbd44e90693797b7badf1d5ecd9adea1a096e
-  data.tar.gz: 0036f2a1623dc4f2fbcd16298aa799412402a2437c7d04aefa3e30b1f0b9f3010b5bf88899f6b98d2a2078416fda7d9047cf683f25a0624d4ecab9cc7df742a8
+  metadata.gz: eef55803823c85357152265d6b9050394151111b782c233c264857837a35e822149c4f93c792fd1f79b9917c1c6956c7237949dd11f5ba057908b9b0a31372ae
+  data.tar.gz: 2dc4f7ee486216838700097498ff5b545307780ba274fd869a4c40accd46799f1111dcdeb12b55518926de4bce1339c57bdf5d42ba581fc3e17c452aa5e42aa1

data/CHANGELOG.md

@@ -1,6 +1,11 @@
 # Changelog
 
 All notable changes to this project will be documented in this file.
+## [0.3.6] - 2026-03-06
+### Changed
+- Optimizes instantiation of scope stack for improved performance.
+- Refactors min/max operations for improved performance.
+
 ## [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.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    shiny_json_logic (0.3.5)
+    shiny_json_logic (0.3.6)
 
 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.6-brightgreen)
+![Ruby](https://img.shields.io/badge/ruby-%3E%3D%202.4-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.6+ compatible**, one of the lowest minimum versions supported in the Ruby ecosystem.
+- 🕰️ **Ruby 2.4+ 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/engine.rb

@@ -8,10 +8,9 @@ module ShinyJsonLogic
     OPERATIONS = OperatorSolver::SOLVERS
 
     def self.call(rule, scope_stack)
-      if rule.is_a?(Utils::DataHash)
-        rule
-      elsif rule.is_a?(Hash)
-        return rule if rule.empty?
+      if rule.is_a?(Hash)
+        # DataHash marks already-resolved user data — return as-is without dispatch
+        return rule if rule.is_a?(Utils::DataHash) || rule.empty?
 
         raise Errors::UnknownOperator if rule.size > 1
 
@@ -24,7 +23,15 @@ module ShinyJsonLogic
 
         op.call(args, scope_stack)
       elsif rule.is_a?(Array)
-        rule.map { |val| call(val, scope_stack) }
+        # Use while loop instead of map — avoids Enumerator overhead on Ruby 3.4 no-YJIT
+        n = rule.size
+        result = Array.new(n)
+        i = 0
+        while i < n
+          result[i] = call(rule[i], scope_stack)
+          i += 1
+        end
+        result
       else
         rule
       end

data/lib/shiny_json_logic/numericals/min_max_collection.rb

@@ -7,21 +7,29 @@ module ShinyJsonLogic
     module MinMaxCollection
       module_function
 
-      def collect_numeric_values(rules, scope_stack)
-        values = collect_values(rules, scope_stack)
-        raise Errors::InvalidArguments if values.empty?
-        values.each { |v| raise Errors::InvalidArguments unless v.is_a?(Numeric) }
-        values
-      end
-
-      def collect_values(rules, scope_stack)
-        if Operations::Base.op?(rules)
-          evaluated = Engine.call(rules, scope_stack)
-          return Utils::Array.wrap_nil(evaluated)
+      def resolve(rules, scope_stack, op)
+        if rules.is_a?(Hash) && !rules.empty? && Engine::OPERATIONS.key?(rules.first[0].to_s)
+          items = Utils::Array.wrap_nil(Engine.call(rules, scope_stack))
+          evaluated = true
+        else
+          items = Utils::Array.wrap_nil(rules)
+          evaluated = false
         end
 
-        wrapped = Utils::Array.wrap_nil(rules)
-        wrapped.map { |rule| Engine.call(rule, scope_stack) }
+        raise Errors::InvalidArguments if items.empty?
+
+        best = evaluated ? items[0] : Engine.call(items[0], scope_stack)
+        raise Errors::InvalidArguments unless best.is_a?(Numeric)
+
+        i = 1
+        n = items.size
+        while i < n
+          v = evaluated ? items[i] : Engine.call(items[i], scope_stack)
+          raise Errors::InvalidArguments unless v.is_a?(Numeric)
+          best = v if op == :min ? v < best : v > best
+          i += 1
+        end
+        best
       end
     end
   end

data/lib/shiny_json_logic/operations/addition.rb

@@ -11,10 +11,14 @@ module ShinyJsonLogic
 
       def self.execute(rules, scope_stack)
         safe_arithmetic do
+          operands = Utils::Array.wrap_nil(rules)
           result = 0.0
-          Utils::Array.wrap_nil(rules).each do |rule|
-            val = Numericals::Numerify.numerify(evaluate(rule, scope_stack))
+          i = 0
+          n = operands.size
+          while i < n
+            val = Numericals::Numerify.numerify(evaluate(operands[i], scope_stack))
             result += val.nil? ? 0 : val
+            i += 1
           end
           result
         end

data/lib/shiny_json_logic/operations/and.rb

@@ -15,9 +15,12 @@ module ShinyJsonLogic
         return false if rules.empty?
 
         result = nil
-        rules.each do |rule|
-          result = evaluate(rule, scope_stack)
+        i = 0
+        n = rules.size
+        while i < n
+          result = evaluate(rules[i], scope_stack)
           return result unless Truthy.call(result)
+          i += 1
         end
         result
       end

data/lib/shiny_json_logic/operations/base.rb

@@ -13,10 +13,14 @@ module ShinyJsonLogic
       end
 
       def self.resolve_rules(rules, scope_stack)
-        dynamic = op?(rules)
-        raise Errors::InvalidArguments if dynamic && raise_on_dynamic_args?
-
-        return Engine.call(rules, scope_stack) if dynamic
+        # Inline op? check to avoid extra method-call overhead on the hot path.
+        # Most rule args are primitives/arrays — the is_a?(Hash) guard is cheap.
+        if rules.is_a?(Hash) && !rules.empty? && !rules.is_a?(Utils::DataHash)
+          key = rules.first[0]
+          return rules unless Engine::OPERATIONS.key?(key.to_s)
+          raise Errors::InvalidArguments if raise_on_dynamic_args?
+          return Engine.call(rules, scope_stack)
+        end
         rules
       end
 

data/lib/shiny_json_logic/operations/coalesce.rb

@@ -6,9 +6,12 @@ module ShinyJsonLogic
   module Operations
     class Coalesce < Base
       def self.execute(rules, scope_stack)
-        rules.each do |rule|
-          result = evaluate(rule, scope_stack)
+        i = 0
+        n = rules.size
+        while i < n
+          result = evaluate(rules[i], scope_stack)
           return result unless result.nil?
+          i += 1
         end
         nil
       end

data/lib/shiny_json_logic/operations/concatenation.rb

@@ -6,12 +6,25 @@ module ShinyJsonLogic
   module Operations
     class Concatenation < Base
       def self.execute(rules, scope_stack)
-        result = []
-        Utils::Array.wrap_nil(rules).each do |rule|
-          evaluated = evaluate(rule, scope_stack)
-          Utils::Array.wrap_nil(evaluated).each { |v| result << v.to_s }
+        result = +""
+        operands = Utils::Array.wrap_nil(rules)
+        i = 0
+        n = operands.size
+        while i < n
+          evaluated = evaluate(operands[i], scope_stack)
+          if evaluated.is_a?(Array)
+            j = 0
+            m = evaluated.size
+            while j < m
+              result << evaluated[j].to_s
+              j += 1
+            end
+          else
+            result << evaluated.to_s
+          end
+          i += 1
         end
-        result.join
+        result
       end
     end
   end

data/lib/shiny_json_logic/operations/division.rb

@@ -15,14 +15,17 @@ module ShinyJsonLogic
 
         result = nil
         count = 0
+        i = 0
+        n = operands.size
 
         begin
-          operands.each do |rule|
-            evaluated = evaluate(rule, scope_stack)
+          while i < n
+            evaluated = evaluate(operands[i], scope_stack)
             num = Numericals::Numerify.numerify(evaluated)
             return handle_nan if num.nil?
             count += 1
             result = result.nil? ? num : result / num
+            i += 1
           end
         rescue TypeError
           return handle_nan

data/lib/shiny_json_logic/operations/exists.rb

@@ -6,17 +6,17 @@ module ShinyJsonLogic
   module Operations
     class Exists < Base
       def self.execute(rules, scope_stack)
-        current = scope_stack.current
-
-        Utils::Array.wrap_nil(rules).each do |rule|
-          segment = evaluate(rule, scope_stack)
-          return false unless current.key?(segment)
+        current = scope_stack.last
+        operands = Utils::Array.wrap_nil(rules)
+        i = 0
+        n = operands.size
+        while i < n
+          segment = evaluate(operands[i], scope_stack)
+          return false unless current.is_a?(Hash) && current.key?(segment)
           current = current[segment]
+          i += 1
         end
-
         true
-      rescue StandardError
-        false
       end
     end
   end

data/lib/shiny_json_logic/operations/filter.rb

@@ -11,17 +11,23 @@ module ShinyJsonLogic
 
       def self.call(rules, scope_stack)
         rules = resolve_rules(rules, scope_stack)
+        filter = setup_filter(rules)
+        collection = setup_collection(rules, scope_stack)
 
-        collection, filter = setup_collection(rules, scope_stack)
-
-        collection.each_with_object([]) do |item, acc|
-          scope_stack.push(item)
+        result = []
+        i = 0
+        n = collection.size
+        while i < n
+          item = collection[i]
+          scope_stack << item
           begin
-            acc << item if Truthy.call(Engine.call(filter, scope_stack))
+            result << item if Truthy.call(Engine.call(filter, scope_stack))
           ensure
             scope_stack.pop
           end
+          i += 1
         end
+        result
       end
     end
   end

data/lib/shiny_json_logic/operations/inclusion.rb

@@ -13,7 +13,14 @@ module ShinyJsonLogic
         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 }
+          i = 0
+          n = haystack.size
+          while i < n
+            el = haystack[i]
+            return true if (el.is_a?(Symbol) ? el.to_s : el) == needle
+            i += 1
+          end
+          false
         else
           haystack.include?(needle)
         end

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

@@ -14,38 +14,43 @@ module ShinyJsonLogic
           @raise_on_nil_filter
         end
 
+        def self.setup_filter(rules)
+          raise Errors::InvalidArguments unless rules.is_a?(Array)
+          filter = rules[1]
+          raise Errors::InvalidArguments if filter.nil? && raise_on_nil_filter?
+          filter
+        end
+
+        def self.setup_collection(rules, scope_stack)
+          collection_rule = rules.size > 0 ? rules[0] : rules
+          raise Errors::InvalidArguments if collection_rule.nil?
+          Utils::Array.wrap(Engine.call(collection_rule, scope_stack))
+        end
+
         def self.call(rules, scope_stack)
           rules = resolve_rules(rules, scope_stack)
-
-          collection, filter = setup_collection(rules, scope_stack)
+          filter = setup_filter(rules)
+          collection = setup_collection(rules, scope_stack)
 
           early = catch(:early_return) do
-            results = collection.each_with_object([]) do |item, acc|
-              scope_stack.push(item)
+            results = []
+            i = 0
+            n = collection.size
+            while i < n
+              item = collection[i]
+              scope_stack << item
               begin
-                acc << on_each(item, filter, scope_stack)
+                results << on_each(item, filter, scope_stack)
               ensure
                 scope_stack.pop
               end
+              i += 1
             end
             on_after(results, scope_stack)
           end
           early
         end
 
-        def self.setup_collection(rules, scope_stack)
-          return handle_nil unless rules.is_a?(Array)
-
-          filter = rules[1]
-          return handle_nil if filter.nil? && raise_on_nil_filter?
-
-          collection_rule = rules.any? ? rules[0] : rules
-          return handle_nil if collection_rule.nil?
-
-          collection = Utils::Array.wrap(Engine.call(collection_rule, scope_stack))
-          [collection, filter]
-        end
-
         def self.on_each(_item, filter, scope_stack)
           Engine.call(filter, scope_stack)
         end
@@ -53,10 +58,6 @@ module ShinyJsonLogic
         def self.on_after(results, _scope_stack)
           results
         end
-
-        def self.handle_nil
-          raise Errors::InvalidArguments
-        end
       end
     end
   end

data/lib/shiny_json_logic/operations/max.rb

@@ -7,7 +7,7 @@ module ShinyJsonLogic
   module Operations
     class Max < Base
       def self.execute(rules, scope_stack)
-        Numericals::MinMaxCollection.collect_numeric_values(rules, scope_stack).max
+        Numericals::MinMaxCollection.resolve(rules, scope_stack, :max)
       end
     end
   end

data/lib/shiny_json_logic/operations/merge.rb

@@ -6,9 +6,20 @@ module ShinyJsonLogic
   module Operations
     class Merge < Base
       def self.execute(rules, scope_stack)
-        Utils::Array.wrap_nil(rules).map do |rule|
-          Utils::Array.wrap_nil(evaluate(rule, scope_stack))
-        end.reduce([], :+)
+        result = []
+        operands = Utils::Array.wrap_nil(rules)
+        i = 0
+        n = operands.size
+        while i < n
+          evaluated = evaluate(operands[i], scope_stack)
+          if evaluated.is_a?(Array)
+            result.concat(evaluated)
+          else
+            result << evaluated
+          end
+          i += 1
+        end
+        result
       end
     end
   end

data/lib/shiny_json_logic/operations/min.rb

@@ -7,7 +7,7 @@ module ShinyJsonLogic
   module Operations
     class Min < Base
       def self.execute(rules, scope_stack)
-        Numericals::MinMaxCollection.collect_numeric_values(rules, scope_stack).min
+        Numericals::MinMaxCollection.resolve(rules, scope_stack, :min)
       end
     end
   end

data/lib/shiny_json_logic/operations/missing.rb

@@ -7,34 +7,55 @@ module ShinyJsonLogic
   module Operations
     class Missing < Base
       def self.execute(rules, scope_stack)
-        items = Utils::Array.wrap_nil(rules)
+        wrapped = Utils::Array.wrap_nil(rules)
         keys = []
-        items.each do |rule|
-          evaluated = evaluate(rule, scope_stack)
-          keys.concat(Utils::Array.wrap_nil(evaluated).map(&:to_s))
+        i = 0
+        n = wrapped.size
+        while i < n
+          evaluated = evaluate(wrapped[i], scope_stack)
+          if evaluated.is_a?(Array)
+            j = 0
+            m = evaluated.size
+            while j < m
+              keys << evaluated[j].to_s
+              j += 1
+            end
+          else
+            keys << evaluated.to_s
+          end
+          i += 1
         end
-        current_data = scope_stack.current
+
+        current_data = scope_stack.last
         return keys unless current_data.is_a?(Hash)
 
-        keys - deep_keys(current_data)
+        existing = {}
+        deep_keys(current_data, nil, existing)
+
+        result = []
+        i = 0
+        n = keys.size
+        while i < n
+          result << keys[i] unless existing.key?(keys[i])
+          i += 1
+        end
+        result
       end
 
-      def self.deep_keys(hash, prefix = nil)
+      def self.deep_keys(hash, prefix, acc)
         return unless hash.is_a?(Hash)
 
-        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)
+          if val.is_a?(Hash)
+            deep_keys(val, full_key, acc)
           else
-            result << full_key
+            acc[full_key] = true
           end
         end
-        result
       end
+
       private_class_method :deep_keys
     end
   end

data/lib/shiny_json_logic/operations/missing_some.rb

@@ -8,13 +8,29 @@ module ShinyJsonLogic
     class MissingSome < Missing
       def self.execute(rules, scope_stack)
         min_required = evaluate(rules[0], scope_stack)
-        keys = Utils::Array.wrap_nil(evaluate(rules[1], scope_stack)).map(&:to_s)
-        current_data = scope_stack.current
+        raw_keys = evaluate(rules[1], scope_stack)
+        raw_keys_arr = wrap_nil(raw_keys)
+        keys = Array.new(raw_keys_arr.size)
+        i = 0
+        n = raw_keys_arr.size
+        while i < n
+          keys[i] = raw_keys_arr[i].to_s
+          i += 1
+        end
+
+        current_data = scope_stack.last
         return keys unless current_data.is_a?(Hash) && rules.is_a?(Array)
 
-        data_keys = current_data.keys.map(&:to_s)
-        present = keys & data_keys
-        present.size >= min_required ? [] : Missing.execute(keys, scope_stack)
+        data_keys = current_data.keys
+        data_keys_s = Array.new(data_keys.size)
+        j = 0
+        m = data_keys.size
+        while j < m
+          data_keys_s[j] = data_keys[j].to_s
+          j += 1
+        end
+        present = keys & data_keys_s
+        present.size >= min_required ? [] : keys - present
       end
     end
   end

data/lib/shiny_json_logic/operations/modulo.rb

@@ -16,12 +16,15 @@ module ShinyJsonLogic
         safe_arithmetic do
           result = nil
           count = 0
+          i = 0
+          n = operands.size
 
-          operands.each do |rule|
-            evaluated = evaluate(rule, scope_stack)
+          while i < n
+            evaluated = evaluate(operands[i], scope_stack)
             num = Numericals::Numerify.numerify(evaluated)
             count += 1
             result = result.nil? ? num : result.remainder(num)
+            i += 1
           end
 
           return handle_invalid_args if count < 2

data/lib/shiny_json_logic/operations/or.rb

@@ -15,9 +15,12 @@ module ShinyJsonLogic
         return false if rules.empty?
 
         result = nil
-        rules.each do |rule|
-          result = evaluate(rule, scope_stack)
+        i = 0
+        n = rules.size
+        while i < n
+          result = evaluate(rules[i], scope_stack)
           return result if Truthy.call(result)
+          i += 1
         end
         result
       end

data/lib/shiny_json_logic/operations/preserve.rb

@@ -9,11 +9,13 @@ module ShinyJsonLogic
       def self.call(rules, scope_stack)
         # Preserve doesn't create new scopes - evaluates each item directly
         collection = Utils::Array.wrap(rules)
-
-        results = collection.each_with_object([]) do |item, acc|
-          acc << Engine.call(item, scope_stack)
+        n = collection.size
+        results = Array.new(n)
+        i = 0
+        while i < n
+          results[i] = Engine.call(collection[i], scope_stack)
+          i += 1
         end
-
         results.size == 1 ? results.first : results
       end
     end

data/lib/shiny_json_logic/operations/product.rb

@@ -16,14 +16,17 @@ module ShinyJsonLogic
         safe_arithmetic do
           result = nil
           count = 0
+          i = 0
+          n = operands.size
 
-          operands.each do |rule|
-            evaluated = evaluate(rule, scope_stack)
+          while i < n
+            evaluated = evaluate(operands[i], scope_stack)
             num = Numericals::Numerify.numerify(evaluated)
             num = 0 if num.nil?
             return handle_nan if num.nil?
             count += 1
             result = result.nil? ? num.to_f : result * num.to_f
+            i += 1
           end
 
           return 1 if count == 0

data/lib/shiny_json_logic/operations/reduce.rb

@@ -12,24 +12,26 @@ module ShinyJsonLogic
 
       def self.call(rules, scope_stack)
         rules = resolve_rules(rules, scope_stack)
+        filter = setup_filter(rules)
+          collection = setup_collection(rules, scope_stack)
 
-        collection, filter = setup_collection(rules, scope_stack)
+          accumulator = Engine.call(rules[2], scope_stack)
 
-        # Evaluate initial accumulator (third argument)
-        accumulator = Engine.call(rules[2], scope_stack)
+          reduce_scope = { "current" => nil, "accumulator" => nil }
+          scope_stack << reduce_scope
 
-        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)
+            i = 0
+            n = collection.size
+            while i < n
+              reduce_scope["current"] = collection[i]
+              reduce_scope["accumulator"] = accumulator
+              accumulator = Engine.call(filter, scope_stack)
+              i += 1
+            end
           ensure
             scope_stack.pop
           end
-        end
 
         safe_arithmetic { accumulator }
       end

data/lib/shiny_json_logic/operations/subtraction.rb

@@ -16,13 +16,16 @@ module ShinyJsonLogic
         safe_arithmetic do
           result = nil
           count = 0
+          i = 0
+          n = operands.size
 
-          operands.each do |rule|
-            evaluated = evaluate(rule, scope_stack)
+          while i < n
+            evaluated = evaluate(operands[i], scope_stack)
             num = Numericals::Numerify.numerify(evaluated)
             num = 0 if num.nil?
             count += 1
             result = result.nil? ? num : result - num
+            i += 1
           end
 
           return handle_invalid_args if count == 0

data/lib/shiny_json_logic/operations/throw.rb

@@ -16,7 +16,7 @@ module ShinyJsonLogic
           end
 
         extracted_type = error_type.is_a?(Hash) && error_type.key?("type") ? error_type["type"] : error_type
-        extracted_type = scope_stack.current["type"] if extracted_type.nil?
+        extracted_type = scope_stack.last["type"] if extracted_type.nil?
 
         raise Errors::Base.new(type: extracted_type)
       end

data/lib/shiny_json_logic/operations/try.rb

@@ -6,12 +6,15 @@ module ShinyJsonLogic
       def self.call(rules, scope_stack)
         items = Utils::Array.wrap_nil(rules)
         last_error = nil
+        i = 0
+        n = items.size
 
-        items.each do |item|
+        while i < n
+          item = items[i]
           # If previous item was an error, switch context to error payload
           if last_error
-            scope_stack.push({})  # intermediate level for [[1]] access
-            scope_stack.push(last_error.payload)
+            scope_stack << {}  # intermediate level for [[1]] access
+            scope_stack << last_error.payload
           end
 
           begin
@@ -34,6 +37,7 @@ module ShinyJsonLogic
 
             last_error = e
           end
+          i += 1
         end
 
         # All items were errors, re-raise the last one

data/lib/shiny_json_logic/operations/val.rb

@@ -8,11 +8,21 @@ module ShinyJsonLogic
   module Operations
     class Val < Base
       def self.execute(rules, scope_stack)
+        # Fast path: null or empty → return current scope
+        if rules.nil?
+          return Utils::DataHash.wrap(scope_stack.last)
+        end
+
+        # Fast path: single string key (most common case)
+        if rules.is_a?(String)
+          return Utils::DataHash.wrap(Utils::HashFetch.fetch(scope_stack.last, rules))
+        end
+
         raw_keys = Utils::Array.wrap_nil(rules)
 
-        # {"val": []} or {"val": null} - return current scope
+        # {"val": []} - return current scope
         if raw_keys.empty? || raw_keys == [nil]
-          return Utils::DataHash.wrap(scope_stack.current)
+          return Utils::DataHash.wrap(scope_stack.last)
         end
 
         # Check if first element is an array (scope navigation syntax)
@@ -29,12 +39,18 @@ module ShinyJsonLogic
           end
 
           levels = level_indicator.abs
-          return Utils::DataHash.wrap(scope_stack.resolve(levels, *evaluated_keys))
+          return Utils::DataHash.wrap(ScopeStack.resolve(scope_stack, levels, evaluated_keys))
         end
 
-        # Normal case: {"val": "key"} or {"val": ["key1", "key2"]}
-        keys = raw_keys.map { |rule| evaluate(rule, scope_stack) }
-        current_data = scope_stack.current
+        # Normal case: {"val": ["key1", "key2"]}
+        keys_n = raw_keys.size
+        keys = Array.new(keys_n)
+        ki = 0
+        while ki < keys_n
+          keys[ki] = evaluate(raw_keys[ki], scope_stack)
+          ki += 1
+        end
+        current_data = scope_stack.last
         Utils::DataHash.wrap(dig_value(current_data, keys))
       end
 
@@ -42,10 +58,15 @@ module ShinyJsonLogic
         return nil if data.nil?
         return data if keys.empty?
 
-        keys.reduce(data) do |obj, key|
+        obj = data
+        i = 0
+        n = keys.size
+        while i < n
           return nil if obj.nil?
-          Utils::HashFetch.fetch(obj, key.to_s)
+          obj = Utils::HashFetch.fetch(obj, keys[i].to_s)
+          i += 1
         end
+        obj
       end
       private_class_method :dig_value
     end

data/lib/shiny_json_logic/operations/var.rb

@@ -11,29 +11,35 @@ module ShinyJsonLogic
       def self.execute(rules, scope_stack)
         # Fast path: simple string key, no default
         if rules.is_a?(String)
-          current_data = scope_stack.current
+          current_data = scope_stack.last
           if rules.empty?
-            return Utils::DataHash.wrap(current_data)
+            return wrap(current_data)
           end
-          return Utils::DataHash.wrap(fetch_value(current_data, rules))
+          return wrap(fetch_value(current_data, rules))
         end
 
         items = Utils::Array.wrap_nil(rules)
         key = evaluate(items[0], scope_stack)
         default = items.length > 1 ? evaluate(items[1], scope_stack) : nil
-        current_data = scope_stack.current
+        current_data = scope_stack.last
 
         if key.nil? || key == ""
-          return Utils::DataHash.wrap(current_data)
+          return wrap(current_data)
         end
 
         result = fetch_value(current_data, key)
         result = result.nil? ? default : result
-        Utils::DataHash.wrap(result)
-      rescue
-        default || scope_stack.current
+        wrap(result)
+        rescue
+        default || scope_stack.last
       end
 
+      # Only wrap Hash values — non-Hash values can't be confused with operators.
+      def self.wrap(value)
+        value.is_a?(::Hash) ? Utils::DataHash.wrap(value) : value
+      end
+      private_class_method :wrap
+
       def self.fetch_value(obj, key)
         return nil if obj.nil?
 

data/lib/shiny_json_logic/operator_solver.rb

@@ -56,7 +56,7 @@ module ShinyJsonLogic
     def self.operation?(value)
       # 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) }
+      value.each_key { |key| return SOLVER_KEYS.include?(key.to_s) }
       false
     end
   end

data/lib/shiny_json_logic/scope_stack.rb

@@ -3,68 +3,43 @@
 require "shiny_json_logic/utils/hash_fetch"
 
 module ShinyJsonLogic
-  # Manages a stack of scopes for nested data access in iterators.
+  # Helpers for navigating the scope stack in nested iterators.
   #
-  # The scope stack allows:
-  # - `current` - returns the top of the stack (current item in iterator)
-  # - `resolve(n, *keys)` - go up n levels, then access keys via dig
-  # - `push(scope)` / `pop` - manage stack during iteration
+  # The scope stack is a plain Array passed as an argument — no object instantiation.
+  # Each entry is a scope (Hash or value). The last entry is the current scope.
   #
-  # When inside an iterator like map:
-  #   {"val": []} -> returns current scope (the item being iterated)
-  #   {"val": [[1], "key"]} -> go up 1 level, access "key"
-  #   {"val": [[2], "key"]} -> go up 2 levels, access "key"
+  # Entering/exiting a scope:
+  #   scope_stack << item   (push)
+  #   scope_stack.pop       (pop)
+  #   scope_stack.last      (current)
   #
-  # Note: Data is normalized to string keys upfront in ShinyJsonLogic.apply,
-  # so no indifferent access is needed here.
+  # Cross-level navigation (val + [[n]] syntax) uses ScopeStack.resolve.
   #
-  class ScopeStack
-    def initialize(root_data)
-      @data_stack = [root_data]
-    end
-
-    # Push a new scope onto the stack (when entering an iteration)
-    def push(data)
-      @data_stack << data
-    end
-
-    # Pop the top scope (when exiting an iteration)
-    def pop
-      @data_stack.pop if @data_stack.size > 1
-    end
+  module ScopeStack
+    module_function
 
-    # Returns the current scope's data (top of stack)
-    def current
-      @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 = @data_stack.size - 1 - levels
+    # Resolve a value by going up n levels and then accessing keys.
+    # Used by val.rb for {"val": [[n], "key"]} syntax.
+    def resolve(stack, levels, keys)
+      target_index = stack.size - 1 - levels
       return nil if target_index < 0
 
-      data = @data_stack[target_index]
-
-      if keys.empty?
-        data
-      else
-        dig_value(data, keys)
-      end
+      data = stack[target_index]
+      keys.empty? ? data : dig_value(data, keys)
     end
 
-    private
-
     def dig_value(data, keys)
       return nil if data.nil?
 
-      keys.reduce(data) do |obj, key|
+      obj = data
+      i = 0
+      n = keys.size
+      while i < n
         return nil if obj.nil?
-        Utils::HashFetch.fetch(obj, key.to_s)
+        obj = Utils::HashFetch.fetch(obj, keys[i].to_s)
+        i += 1
       end
+      obj
     end
   end
 end

data/lib/shiny_json_logic/truthy.rb

@@ -9,9 +9,17 @@ module ShinyJsonLogic
       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
+      when Array
+        i = 0
+        n = subject.size
+        while i < n
+          return true if subject[i]
+          i += 1
+        end
+        false
+      else
+        true
       end
     end
   end

data/lib/shiny_json_logic/utils/array.rb

@@ -8,15 +8,12 @@ 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]
       end
 
       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)
 
         [object]
       end

data/lib/shiny_json_logic/version.rb

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

data/lib/shiny_json_logic.rb

@@ -11,7 +11,7 @@ require "shiny_json_logic/scope_stack"
 
 module ShinyJsonLogic
   def self.apply(rule, data = {})
-    scope_stack = ScopeStack.new(data || {})
+    scope_stack = [data || {}]
     Engine.call(rule, scope_stack)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shiny_json_logic
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
 platform: ruby
 authors:
 - Luis Moyano