shiny_json_logic 0.3.4 → 0.3.6

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/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/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,31 +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
 
-        index_scope = { "index" => 0 }
-        reduce_scope = { "current" => nil, "accumulator" => nil }
-
-        collection.each_with_index do |item, index|
-          index_scope["index"] = index
-          reduce_scope["current"] = item
-          reduce_scope["accumulator"] = accumulator
-          scope_stack.push(index_scope, index: index)
-          scope_stack.push(reduce_scope, index: index)
           begin
-            accumulator = Engine.call(filter, scope_stack)
-            scope_stack.pop
-            scope_stack.pop
-          rescue => e
-            scope_stack.pop
+            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
-            raise e
           end
-        end
 
         safe_arithmetic { accumulator }
       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/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

@@ -9,35 +9,61 @@ 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.last
+          if rules.empty?
+            return wrap(current_data)
+          end
+          return 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
-        current_data = scope_stack.current
+        default = items.length > 1 ? evaluate(items[1], scope_stack) : nil
+        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?
 
-        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.to_s) }
+      false
     end
   end
 end
+

data/lib/shiny_json_logic/scope_stack.rb

@@ -3,73 +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]
-      @index_stack = [0]
-    end
-
-    # Push a new scope onto the stack (when entering an iteration)
-    def push(data, index: 0)
-      @data_stack  << data
-      @index_stack << index
-    end
-
-    # Pop the top scope (when exiting an iteration)
-    def pop
-      if @data_stack.size > 1
-        @data_stack.pop
-        @index_stack.pop
-      end
-    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,16 +8,14 @@ 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)
 
-        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.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.4
+  version: 0.3.6
 platform: ruby
 authors:
 - Luis Moyano