shiny_json_logic 0.2.16 → 0.3.1

data/lib/shiny_json_logic/operations/inclusion.rb

@@ -5,9 +5,9 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Inclusion < Base
-      def call
-        needle = evaluate(rules.first)
-        haystack = evaluate(rules.last)
+      def self.execute(rules, scope_stack)
+        needle = evaluate(rules.first, scope_stack)
+        haystack = evaluate(rules.last, scope_stack)
         haystack.include?(needle)
       end
     end

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

@@ -6,93 +6,63 @@ module ShinyJsonLogic
   module Operations
     module Iterable
       class Base < Operations::Base
-        def initialize(rules, scope_stack)
-          super
-
-          return handle_nil if dynamic_args?
-          return handle_nil unless rules.is_a?(Array)
-
-          @filter = rules[1]
-          return handle_nil if @filter.nil? && self.class.raise_on_nil_filter?
-
-          collection = rules.any? ? rules[0] : rules
-          return handle_nil if collection.nil?
+        def self.raise_on_nil_filter!
+          @raise_on_nil_filter = true
+        end
 
-          setup_collection(collection)
+        def self.raise_on_nil_filter?
+          @raise_on_nil_filter
         end
 
-        def call
-          on_before
+        def self.call(rules, scope_stack)
+          rules = resolve_rules(rules, scope_stack)
 
-          results = collection.each_with_index.each_with_object([]) do |(item, index), results|
-            on_before_each(item, index)
+          collection, filter = setup_collection(rules, scope_stack)
+
+          on_before(scope_stack)
+          results = collection.each_with_index.each_with_object([]) do |(item, index), acc|
+            scope_stack.push({ "index" => index }, index: index)
+            scope_stack.push(item, index: index)
             begin
-              solved = on_each(item)
-              results << solved
-              on_after_each
+              solved = on_each(item, filter, scope_stack)
+              acc << solved
+              scope_stack.pop
+              scope_stack.pop
             rescue => e
-              # Clean up scopes before re-raising
               scope_stack.pop  # item scope
               scope_stack.pop  # iterator context scope
               raise e
             end
           end
-
-          on_after(results)
+          on_after(results, scope_stack)
         end
 
-        protected
+        def self.setup_collection(rules, scope_stack)
+          return handle_nil unless rules.is_a?(Array)
 
-        private
+          filter = rules[1]
+          return handle_nil if filter.nil? && raise_on_nil_filter?
 
-        def on_each(_item)
-          Engine.call(filter, scope_stack)
-        end
+          collection_rule = rules.any? ? rules[0] : rules
+          return handle_nil if collection_rule.nil?
 
-        def on_before_each(item, index = 0)
-          # Push the iterator context first (with index)
-          # This creates the intermediate level for [[1], "index"] access
-          scope_stack.push({ "index" => index }, index: index)
-          
-          # Then push the current item
-          scope_stack.push(item, index: index)
+          collection = Utils::Array.wrap(Engine.call(collection_rule, scope_stack))
+          [collection, filter]
         end
 
-        def on_after_each
-          # Pop the item scope
-          scope_stack.pop
-          # Pop the iterator context scope
-          scope_stack.pop
-        end
+        def self.on_before(_scope_stack); end
 
-        def on_before
+        def self.on_each(_item, filter, scope_stack)
+          Engine.call(filter, scope_stack)
         end
 
-        def on_after(results)
+        def self.on_after(results, _scope_stack)
           results
         end
 
-        def handle_nil
+        def self.handle_nil
           raise Errors::InvalidArguments
         end
-
-        def setup_collection(collection)
-          if collection.nil?
-            @collection = []
-          else
-            @collection = wrap(evaluate(collection))
-          end
-        end
-
-        def self.raise_on_nil_filter!
-          @raise_on_nil_filter = true
-        end
-
-        def self.raise_on_nil_filter?
-          @raise_on_nil_filter
-        end
-
-        attr_reader :collection, :filter
       end
     end
   end

data/lib/shiny_json_logic/operations/max.rb

@@ -6,10 +6,8 @@ require "shiny_json_logic/numericals/min_max_collection"
 module ShinyJsonLogic
   module Operations
     class Max < Base
-      include Numericals::MinMaxCollection
-
-      def call
-        collect_numeric_values.max
+      def self.execute(rules, scope_stack)
+        Numericals::MinMaxCollection.collect_numeric_values(rules, scope_stack).max
       end
     end
   end

data/lib/shiny_json_logic/operations/merge.rb

@@ -5,9 +5,9 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Merge < Base
-      def call
-        wrap_nil(rules).map do |rule|
-          wrap_nil(evaluate(rule))
+      def self.execute(rules, scope_stack)
+        Utils::Array.wrap_nil(rules).map do |rule|
+          Utils::Array.wrap_nil(evaluate(rule, scope_stack))
         end.reduce([], :+)
       end
     end

data/lib/shiny_json_logic/operations/min.rb

@@ -6,10 +6,8 @@ require "shiny_json_logic/numericals/min_max_collection"
 module ShinyJsonLogic
   module Operations
     class Min < Base
-      include Numericals::MinMaxCollection
-
-      def call
-        collect_numeric_values.min
+      def self.execute(rules, scope_stack)
+        Numericals::MinMaxCollection.collect_numeric_values(rules, scope_stack).min
       end
     end
   end

data/lib/shiny_json_logic/operations/missing.rb

@@ -6,25 +6,25 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Missing < Base
-      def call
-        items = wrap_nil(rules)
+      def self.execute(rules, scope_stack)
+        items = Utils::Array.wrap_nil(rules)
         keys = []
         items.each do |rule|
-          evaluated = evaluate(rule)
-          keys.concat(wrap_nil(evaluated).map(&:to_s))
+          evaluated = evaluate(rule, scope_stack)
+          keys.concat(Utils::Array.wrap_nil(evaluated).map(&:to_s))
         end
-        return keys unless data.is_a?(Hash)
+        current_data = scope_stack.current
+        return keys unless current_data.is_a?(Hash)
 
-        keys - deep_keys(data)
+        keys - deep_keys(current_data)
       end
 
-      private
-
-      def deep_keys(hash)
+      def self.deep_keys(hash)
         return unless hash.is_a?(Hash)
 
-        hash.keys.map{|key| ([key.to_s] << deep_keys(hash[key])).compact.join(".") }
+        hash.keys.map { |key| ([key.to_s] << deep_keys(hash[key])).compact.join(".") }
       end
+      private_class_method :deep_keys
     end
   end
 end

data/lib/shiny_json_logic/operations/missing_some.rb

@@ -6,14 +6,15 @@ require "shiny_json_logic/operations/missing"
 module ShinyJsonLogic
   module Operations
     class MissingSome < Missing
-      def call
-        min_required = evaluate(rules[0])
-        keys = wrap_nil(evaluate(rules[1])).map(&:to_s)
-        return keys unless data.is_a?(Hash) && rules.is_a?(Array)
+      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
+        return keys unless current_data.is_a?(Hash) && rules.is_a?(Array)
 
-        data_keys = data.keys.map(&:to_s)
+        data_keys = current_data.keys.map(&:to_s)
         present = keys & data_keys
-        present.size >= min_required ? [] : Missing.new(keys, scope_stack).call
+        present.size >= min_required ? [] : Missing.execute(keys, scope_stack)
       end
     end
   end

data/lib/shiny_json_logic/operations/modulo.rb

@@ -7,18 +7,19 @@ require "shiny_json_logic/numericals/numerify"
 module ShinyJsonLogic
   module Operations
     class Modulo < Base
-      include Numericals::WithErrorHandling
-      include Numericals::Numerify
+      extend Numericals::WithErrorHandling
 
-      def call
-        operands = wrap_nil(rules)
+      def self.execute(rules, scope_stack)
+        operands = Utils::Array.wrap_nil(rules)
         return handle_invalid_args if operands.empty?
 
         safe_arithmetic do
           result = nil
           count = 0
 
-          each_operand(operands) do |num|
+          operands.each do |rule|
+            evaluated = evaluate(rule, scope_stack)
+            num = Numericals::Numerify.numerify(evaluated)
             count += 1
             result = result.nil? ? num : result.remainder(num)
           end
@@ -28,15 +29,6 @@ module ShinyJsonLogic
           result
         end
       end
-
-      private
-
-      def each_operand(operands)
-        operands.each do |rule|
-          evaluated = evaluate(rule)
-          yield numerify(evaluated)
-        end
-      end
     end
   end
 end

data/lib/shiny_json_logic/operations/none.rb

@@ -8,9 +8,7 @@ module ShinyJsonLogic
     class None < Iterable::Base
       raise_on_dynamic_args!
 
-      private
-
-      def on_after(results)
+      def self.on_after(results, _scope_stack)
         return true if results.empty?
 
         results.none? { |res| Truthy.call(res) }

data/lib/shiny_json_logic/operations/not.rb

@@ -6,9 +6,9 @@ require "shiny_json_logic/truthy"
 module ShinyJsonLogic
   module Operations
     class Not < Base
-      def call
+      def self.execute(rules, scope_stack)
         value = rules.is_a?(Array) ? rules.first : rules
-        !Truthy.call(evaluate(value))
+        !Truthy.call(evaluate(value, scope_stack))
       end
     end
   end

data/lib/shiny_json_logic/operations/or.rb

@@ -7,17 +7,16 @@ require "shiny_json_logic/numericals/with_error_handling"
 module ShinyJsonLogic
   module Operations
     class Or < Base
-      include Numericals::WithErrorHandling
+      extend Numericals::WithErrorHandling
       raise_on_dynamic_args!
 
-      def call
-        return handle_invalid_args if dynamic_args?
+      def self.execute(rules, scope_stack)
         return handle_invalid_args unless rules.is_a?(Array)
         return false if rules.empty?
 
         result = nil
         rules.each do |rule|
-          result = evaluate(rule)
+          result = evaluate(rule, scope_stack)
           return result if Truthy.call(result)
         end
         result

data/lib/shiny_json_logic/operations/preserve.rb

@@ -1,37 +1,20 @@
 # frozen_string_literal: true
 
 require "shiny_json_logic/truthy"
+require "shiny_json_logic/operations/iterable/base"
 
 module ShinyJsonLogic
   module Operations
     class Preserve < Iterable::Base
-      def initialize(rules, scope_stack)
-        @collection = wrap(rules) || []
-        # Skip Iterable::Base initialization, go directly to Operations::Base
-        # Preserve doesn't need the standard iterable setup (filter, collection from rules[0], etc.)
-        @rules = rules
-        @scope_stack = scope_stack
-      end
-
-      private
-
-      def on_each(item)
-        Engine.call(item, scope_stack)
-      end
+      def self.call(rules, scope_stack)
+        # Preserve doesn't create new scopes - evaluates each item directly
+        collection = Utils::Array.wrap(rules)
 
-      def on_after(results)
-        return results.first if results.size == 1
-
-        results
-      end
-
-      # Preserve doesn't create new scopes - it just evaluates expressions
-      def on_before_each(_item, _index = 0)
-        # Don't push to scope stack
-      end
+        results = collection.each_with_object([]) do |item, acc|
+          acc << Engine.call(item, scope_stack)
+        end
 
-      def on_after_each
-        # Don't pop from scope stack
+        results.size == 1 ? results.first : results
       end
     end
   end

data/lib/shiny_json_logic/operations/product.rb

@@ -7,18 +7,20 @@ require "shiny_json_logic/numericals/numerify"
 module ShinyJsonLogic
   module Operations
     class Product < Base
-      include Numericals::WithErrorHandling
-      include Numericals::Numerify
+      extend Numericals::WithErrorHandling
 
-      def call
-        operands = wrap_nil(rules)
+      def self.execute(rules, scope_stack)
+        operands = Utils::Array.wrap_nil(rules)
         return 1 if operands.empty?
 
         safe_arithmetic do
           result = nil
           count = 0
 
-          each_operand(operands) do |num|
+          operands.each do |rule|
+            evaluated = evaluate(rule, 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
@@ -29,21 +31,6 @@ module ShinyJsonLogic
           result
         end
       end
-
-      private
-
-      def each_operand(operands)
-        operands.each do |rule|
-          evaluated = evaluate(rule)
-          yield numerify(evaluated)
-        end
-      end
-
-      def numerify(value)
-        val = super
-        return 0 if val.nil?
-        val
-      end
     end
   end
 end

data/lib/shiny_json_logic/operations/reduce.rb

@@ -7,39 +7,33 @@ require "shiny_json_logic/numericals/with_error_handling"
 module ShinyJsonLogic
   module Operations
     class Reduce < Iterable::Base
-      include Numericals::WithErrorHandling
+      extend Numericals::WithErrorHandling
       raise_on_dynamic_args!
 
-      def initialize(rules, scope_stack)
-        # Capture initial accumulator before super (which may pre-process rules)
-        initial_accumulator_rule = rules.is_a?(Array) ? rules[2] : nil
-        super
-        # Evaluate the initial accumulator value (third argument)
-        @accumulator = Engine.call(initial_accumulator_rule, scope_stack)
-      end
-
-      private
-
-      attr_accessor :accumulator
-
-      def on_before_each(item, index = 0)
-        # For reduce, we need to create a special scope with current and accumulator
-        # Push iterator context
-        scope_stack.push({ "index" => index }, index: index)
-        
-        # Push item scope with current and accumulator
-        reduce_scope = { "current" => item, "accumulator" => accumulator }
-        scope_stack.push(reduce_scope, index: index)
-      end
-
-      def on_each(_item)
-        self.accumulator = Engine.call(filter, scope_stack)
-      end
-
-      def on_after(_results)
-        safe_arithmetic do
-          self.accumulator
+      def self.call(rules, scope_stack)
+        rules = resolve_rules(rules, scope_stack)
+
+        collection, filter = setup_collection(rules, scope_stack)
+
+        # Evaluate initial accumulator (third argument)
+        accumulator = Engine.call(rules[2], scope_stack)
+
+        collection.each_with_index do |item, index|
+          scope_stack.push({ "index" => index }, index: index)
+          reduce_scope = { "current" => item, "accumulator" => accumulator }
+          scope_stack.push(reduce_scope, index: index)
+          begin
+            accumulator = Engine.call(filter, scope_stack)
+            scope_stack.pop
+            scope_stack.pop
+          rescue => e
+            scope_stack.pop
+            scope_stack.pop
+            raise e
+          end
         end
+
+        safe_arithmetic { accumulator }
       end
     end
   end

data/lib/shiny_json_logic/operations/smaller.rb

@@ -1,30 +1,15 @@
 # frozen_string_literal: true
 
 require "shiny_json_logic/operations/base"
-require "shiny_json_logic/numericals/with_error_handling"
 require "shiny_json_logic/comparisons/comparable"
 
 module ShinyJsonLogic
   module Operations
     class Smaller < Base
-      include Numericals::WithErrorHandling
-      include Comparisons::Comparable
       raise_on_dynamic_args!
 
-      def call
-        return handle_invalid_args if dynamic_args?
-        operands = wrap_nil(rules)
-        return handle_invalid_args if operands.length < 2
-
-        prev = evaluate(operands[0])
-        operands[1..].each do |rule|
-          curr = evaluate(rule)
-          result = compare(prev, curr)
-          return handle_nan if result == :nan
-          return false unless result == -1
-          prev = curr
-        end
-        true
+      def self.execute(rules, scope_stack)
+        Comparisons::Comparable.compare_chain(rules, scope_stack) { |r| r == -1 }
       end
     end
   end

data/lib/shiny_json_logic/operations/smaller_equal.rb

@@ -1,30 +1,15 @@
 # frozen_string_literal: true
 
 require "shiny_json_logic/operations/base"
-require "shiny_json_logic/numericals/with_error_handling"
 require "shiny_json_logic/comparisons/comparable"
 
 module ShinyJsonLogic
   module Operations
     class SmallerEqual < Base
-      include Numericals::WithErrorHandling
-      include Comparisons::Comparable
       raise_on_dynamic_args!
 
-      def call
-        return handle_invalid_args if dynamic_args?
-        operands = wrap_nil(rules)
-        return handle_invalid_args if operands.length < 2
-
-        prev = evaluate(operands[0])
-        operands[1..].each do |rule|
-          curr = evaluate(rule)
-          result = compare(prev, curr)
-          return handle_nan if result == :nan
-          return false unless result <= 0
-          prev = curr
-        end
-        true
+      def self.execute(rules, scope_stack)
+        Comparisons::Comparable.compare_chain(rules, scope_stack) { |r| r <= 0 }
       end
     end
   end

data/lib/shiny_json_logic/operations/some.rb

@@ -8,9 +8,7 @@ module ShinyJsonLogic
     class Some < Iterable::Base
       raise_on_dynamic_args!
 
-      private
-
-      def on_after(results)
+      def self.on_after(results, _scope_stack)
         results.any? { |res| res == true }
       end
     end

data/lib/shiny_json_logic/operations/strict_different.rb

@@ -1,33 +1,27 @@
 # frozen_string_literal: true
 
 require "shiny_json_logic/operations/base"
+require "shiny_json_logic/comparisons/comparable"
 require "shiny_json_logic/numericals/with_error_handling"
 
 module ShinyJsonLogic
   module Operations
     class StrictDifferent < Base
-      include Numericals::WithErrorHandling
+      extend Numericals::WithErrorHandling
       raise_on_dynamic_args!
 
-      def call
-        return handle_invalid_args if dynamic_args?
-        operands = wrap_nil(rules)
+      def self.execute(rules, scope_stack)
+        operands = Utils::Array.wrap_nil(rules)
         return handle_invalid_args if operands.length < 2
 
-        prev = cast(evaluate(operands[0]))
+        prev = Comparisons::Comparable.cast(evaluate(operands[0], scope_stack))
         operands[1..].each do |rule|
-          curr = cast(evaluate(rule))
+          curr = Comparisons::Comparable.cast(evaluate(rule, scope_stack))
           return false if curr == prev
           prev = curr
         end
         true
       end
-
-      private
-
-      def cast(value)
-        value.is_a?(Numeric) ? value.to_f : value
-      end
     end
   end
 end

data/lib/shiny_json_logic/operations/strict_equal.rb

@@ -1,31 +1,25 @@
 # frozen_string_literal: true
 
 require "shiny_json_logic/operations/base"
+require "shiny_json_logic/comparisons/comparable"
 require "shiny_json_logic/numericals/with_error_handling"
 
 module ShinyJsonLogic
   module Operations
     class StrictEqual < Base
-      include Numericals::WithErrorHandling
+      extend Numericals::WithErrorHandling
       raise_on_dynamic_args!
 
-      def call
-        return handle_invalid_args if dynamic_args?
-        operands = wrap_nil(rules)
+      def self.execute(rules, scope_stack)
+        operands = Utils::Array.wrap_nil(rules)
         return handle_invalid_args if operands.length < 2
 
-        first = cast(evaluate(operands[0]))
+        first = Comparisons::Comparable.cast(evaluate(operands[0], scope_stack))
         operands[1..].each do |rule|
-          return false unless cast(evaluate(rule)) == first
+          return false unless Comparisons::Comparable.cast(evaluate(rule, scope_stack)) == first
         end
         true
       end
-
-      private
-
-      def cast(value)
-        value.is_a?(Numeric) ? value.to_f : value
-      end
     end
   end
 end

data/lib/shiny_json_logic/operations/substring.rb

@@ -5,10 +5,10 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Substring < Base
-      def call
-        str = evaluate(rules[0]).to_s
-        start = evaluate(rules[1]).to_i
-        length = rules[2] ? evaluate(rules[2]).to_i : str.length
+      def self.execute(rules, scope_stack)
+        str = evaluate(rules[0], scope_stack).to_s
+        start = evaluate(rules[1], scope_stack).to_i
+        length = rules[2] ? evaluate(rules[2], scope_stack).to_i : str.length
         start += str.length if start < 0
         start = 0 if start < 0  # clamp negative start to 0
         return "" if start >= str.length