shiny_json_logic 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf0275f81efb49af13061d1c54c2dc273fb4686ad647a43f3ba4eafb069176f5
-  data.tar.gz: d411aa52d5d3a235b5a9c783909acac800e10a620e0294f572ccbca9d7421223
+  metadata.gz: 1ebe927021766f9f1fd019339cbe471dd9d8102e6639cb2c075eb5bf2cf2618c
+  data.tar.gz: a419046895f9b3cdafe511f8a14d39ba641076dec9b41d9c7ada7b6dafc56a8e
 SHA512:
-  metadata.gz: a926de52b731c63259ba2a6a954e35dd0d94c133d78cfb4bfe8c7d862cf8f5d5f9e6a33ad8b9d63028d9cc9cfa97473f6fca92683c27a219bc5838bcd3d626eb
-  data.tar.gz: 112ec835a660537716dd1c94cfa9c152584296a44b857d0161ac3a2dd69c6f2440fd2ccf15542907f2b7a83aeb38a99acce949ad06fb55be62ff20d4687ec55a
+  metadata.gz: efbb1ee13c8fb44f15df4d5ea1d1d6d347fb67e6552059afb54c21b754b1442a4f4b2b4d66b19fbcf804bc28861dbd44e90693797b7badf1d5ecd9adea1a096e
+  data.tar.gz: 0036f2a1623dc4f2fbcd16298aa799412402a2437c7d04aefa3e30b1f0b9f3010b5bf88899f6b98d2a2078416fda7d9047cf683f25a0624d4ecab9cc7df742a8

data/CHANGELOG.md

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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    shiny_json_logic (0.3.4)
+    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,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/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
 

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/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,24 +19,18 @@ 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|
-            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
+          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)
@@ -52,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/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,23 +18,16 @@ 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|
-          index_scope["index"] = index
+        collection.each do |item|
           reduce_scope["current"] = item
           reduce_scope["accumulator"] = accumulator
-          scope_stack.push(index_scope, index: index)
-          scope_stack.push(reduce_scope, index: index)
+          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/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

@@ -9,52 +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
 
     SOLVER_KEYS = Set.new(SOLVERS.keys).freeze
 
     def self.operation?(value)
-      value.keys.any? { |key| SOLVER_KEYS.include?(key.is_a?(String) ? 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

@@ -20,22 +20,17 @@ module ShinyJsonLogic
   #
   class ScopeStack
     def initialize(root_data)
-      @data_stack  = [root_data]
-      @index_stack = [0]
+      @data_stack = [root_data]
     end
 
     # Push a new scope onto the stack (when entering an iteration)
-    def push(data, index: 0)
-      @data_stack  << data
-      @index_stack << index
+    def push(data)
+      @data_stack << data
     end
 
     # Pop the top scope (when exiting an iteration)
     def pop
-      if @data_stack.size > 1
-        @data_stack.pop
-        @index_stack.pop
-      end
+      @data_stack.pop if @data_stack.size > 1
     end
 
     # Returns the current scope's data (top of stack)

data/lib/shiny_json_logic/utils/array.rb

@@ -16,8 +16,9 @@ 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/version.rb

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

metadata

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