shiny_json_logic 0.3.4 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf0275f81efb49af13061d1c54c2dc273fb4686ad647a43f3ba4eafb069176f5
-  data.tar.gz: d411aa52d5d3a235b5a9c783909acac800e10a620e0294f572ccbca9d7421223
+  metadata.gz: cb0d5385d70e0de02275f1a5a4ad0f8d6014c9f8030df64882cb7da1ff44942d
+  data.tar.gz: a608c50e2ef5acb46a348674df1ffeff928274f142f5d71ffbaf1101787b4149
 SHA512:
-  metadata.gz: a926de52b731c63259ba2a6a954e35dd0d94c133d78cfb4bfe8c7d862cf8f5d5f9e6a33ad8b9d63028d9cc9cfa97473f6fca92683c27a219bc5838bcd3d626eb
-  data.tar.gz: 112ec835a660537716dd1c94cfa9c152584296a44b857d0161ac3a2dd69c6f2440fd2ccf15542907f2b7a83aeb38a99acce949ad06fb55be62ff20d4687ec55a
+  metadata.gz: eef55803823c85357152265d6b9050394151111b782c233c264857837a35e822149c4f93c792fd1f79b9917c1c6956c7237949dd11f5ba057908b9b0a31372ae
+  data.tar.gz: 2dc4f7ee486216838700097498ff5b545307780ba274fd869a4c40accd46799f1111dcdeb12b55518926de4bce1339c57bdf5d42ba581fc3e17c452aa5e42aa1

data/CHANGELOG.md

@@ -1,6 +1,16 @@
 # 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.
+- 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.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    shiny_json_logic (0.3.4)
+    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/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,15 +29,24 @@ 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.
@@ -46,9 +56,12 @@ module ShinyJsonLogic
         raise Errors::InvalidArguments if n < 2
 
         prev = Engine.call(operands[0], 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)

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?
-        raise Errors::InvalidArguments unless values.all? { |v| 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/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/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,9 +13,14 @@ module ShinyJsonLogic
       end
 
       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?
+        # 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
 
@@ -36,7 +41,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/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

@@ -9,12 +9,25 @@ 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)
+        filter = setup_filter(rules)
+        collection = setup_collection(rules, scope_stack)
 
-      def self.on_after(results, _scope_stack)
-        results.compact
+        result = []
+        i = 0
+        n = collection.size
+        while i < n
+          item = collection[i]
+          scope_stack << item
+          begin
+            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

@@ -8,7 +8,22 @@ 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)
+          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
       end
     end
   end

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

@@ -14,46 +14,43 @@ module ShinyJsonLogic
           @raise_on_nil_filter
         end
 
-        def self.call(rules, scope_stack)
-          rules = resolve_rules(rules, scope_stack)
-
-          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|
-            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)
-              acc << solved
-              scope_stack.pop
-              scope_stack.pop
-            rescue => e
-              scope_stack.pop  # item scope
-              scope_stack.pop  # iterator context scope
-              raise e
-            end
-          end
-          on_after(results, scope_stack)
+        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)
-          return handle_nil unless rules.is_a?(Array)
-
-          filter = rules[1]
-          return handle_nil if filter.nil? && raise_on_nil_filter?
+          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
 
-          collection_rule = rules.any? ? rules[0] : rules
-          return handle_nil if collection_rule.nil?
+        def self.call(rules, scope_stack)
+          rules = resolve_rules(rules, scope_stack)
+          filter = setup_filter(rules)
+          collection = setup_collection(rules, scope_stack)
 
-          collection = Utils::Array.wrap(Engine.call(collection_rule, scope_stack))
-          [collection, filter]
+          early = catch(:early_return) do
+            results = []
+            i = 0
+            n = collection.size
+            while i < n
+              item = collection[i]
+              scope_stack << item
+              begin
+                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.on_before(_scope_stack); end
-
         def self.on_each(_item, filter, scope_stack)
           Engine.call(filter, scope_stack)
         end
@@ -61,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