shiny_json_logic 0.2.6 → 0.2.7

data/lib/shiny_json_logic/operations/exists.rb

@@ -8,9 +8,9 @@ module ShinyJsonLogic
       def run
         current = data
 
-        Array.wrap(rules).each do |segment|
+        Array.wrap_nil(rules).each do |rule|
+          segment = evaluate(rule)
           return false unless current.key?(segment)
-
           current = current[segment]
         end
 

data/lib/shiny_json_logic/operations/filter.rb

@@ -4,6 +4,8 @@ require "shiny_json_logic/operations/iterable/base"
 module ShinyJsonLogic
   module Operations
     class Filter < Iterable::Base
+      raise_on_nil_filter!
+
       private
 
       def on_each(item)

data/lib/shiny_json_logic/operations/greater.rb

@@ -1,12 +1,56 @@
 require "shiny_json_logic/operations/base"
+require "shiny_json_logic/numericals/with_error_handling"
+require "shiny_json_logic/numericals/numerify"
 
 module ShinyJsonLogic
   module Operations
     class Greater < Base
+      include Numericals::WithErrorHandling
+      include Numericals::Numerify
+
       protected
 
       def run
-        rules.map(&:to_f).each_cons(2).all? { |a, b| a.to_f > b.to_f }
+        operands = Array.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
+      end
+
+      private
+
+      def compare(a, b)
+        # Arrays u objetos → NaN
+        return :nan if a.is_a?(Array) || a.is_a?(Hash) || b.is_a?(Array) || b.is_a?(Hash)
+
+        # Ambos strings → comparación lexicográfica
+        if a.is_a?(String) && b.is_a?(String)
+          return a <=> b
+        end
+
+        # Convertir a números para comparar
+        num_a = numerify_for_compare(a)
+        num_b = numerify_for_compare(b)
+        return :nan if num_a.nil? || num_b.nil?
+
+        num_a <=> num_b
+      end
+
+      def numerify_for_compare(value)
+        return value.to_f if value.is_a?(Numeric)
+        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) && numeric_string?(value)
+        nil # String no numérica
       end
     end
   end

data/lib/shiny_json_logic/operations/greater_equal.rb

@@ -1,12 +1,56 @@
 require "shiny_json_logic/operations/base"
+require "shiny_json_logic/numericals/with_error_handling"
+require "shiny_json_logic/numericals/numerify"
 
 module ShinyJsonLogic
   module Operations
     class GreaterEqual < Base
+      include Numericals::WithErrorHandling
+      include Numericals::Numerify
+
       protected
 
       def run
-        rules.map(&:to_f).each_cons(2).all? { |a, b| a.to_f >= b.to_f }
+        operands = Array.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
+      end
+
+      private
+
+      def compare(a, b)
+        # Arrays u objetos → NaN
+        return :nan if a.is_a?(Array) || a.is_a?(Hash) || b.is_a?(Array) || b.is_a?(Hash)
+
+        # Ambos strings → comparación lexicográfica
+        if a.is_a?(String) && b.is_a?(String)
+          return a <=> b
+        end
+
+        # Convertir a números para comparar
+        num_a = numerify_for_compare(a)
+        num_b = numerify_for_compare(b)
+        return :nan if num_a.nil? || num_b.nil?
+
+        num_a <=> num_b
+      end
+
+      def numerify_for_compare(value)
+        return value.to_f if value.is_a?(Numeric)
+        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) && numeric_string?(value)
+        nil # String no numérica
       end
     end
   end

data/lib/shiny_json_logic/operations/inclusion.rb

@@ -6,7 +6,9 @@ module ShinyJsonLogic
       protected
 
       def run
-        rules.last.include? rules.first
+        needle = evaluate(rules.first)
+        haystack = evaluate(rules.last)
+        haystack.include?(needle)
       end
     end
   end

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

@@ -6,20 +6,14 @@ module ShinyJsonLogic
       class Base < Operations::Base
         def initialize(context)
           super
-          collection = rules.any? ? rules[0] : rules
-          return handle_nil_collection if collection.nil?
-
-          if collection.nil?
-            @collection = []
-          else
-            Engine.new(collection, data).tap do |engine|
-              call = engine.call
-              @collection = Array.wrap(call)
-              self.errors = [*self.errors, *engine.errors]
-            end
-          end
 
           @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?
+
+          setup_collection(collection)
         end
 
         def call
@@ -47,9 +41,8 @@ module ShinyJsonLogic
         private
 
         def on_each(_item)
-          Engine.new(filter, data).then do |engine|
-            [engine.call, engine]
-          end
+          engine = Engine.new(filter, data)
+          [engine.call, engine]
         end
 
         def on_before_each(item)
@@ -72,13 +65,29 @@ module ShinyJsonLogic
           ""
         end
 
-        def handle_nil_collection
+        def handle_nil
           error = Errors::Base.new(type: "Invalid Arguments")
           self.errors = [error]
 
           error.id
         end
 
+        def setup_collection(collection)
+          if collection.nil?
+            @collection = []
+          else
+            @collection = Array.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

data/lib/shiny_json_logic/operations/map.rb

@@ -0,0 +1,10 @@
+require "shiny_json_logic/truthy"
+require "shiny_json_logic/operations/iterable/base"
+
+module ShinyJsonLogic
+  module Operations
+    class Map < Iterable::Base
+      raise_on_nil_filter!
+    end
+  end
+end

data/lib/shiny_json_logic/operations/max.rb

@@ -6,7 +6,13 @@ module ShinyJsonLogic
       protected
 
       def run
-        rules.max
+        result = nil
+        Array.wrap_nil(rules).each do |rule|
+          Array.wrap_nil(evaluate(rule)).each do |val|
+            result = val if result.nil? || val > result
+          end
+        end
+        result
       end
     end
   end

data/lib/shiny_json_logic/operations/merge.rb

@@ -6,7 +6,9 @@ module ShinyJsonLogic
       protected
 
       def run
-        rules.map{ |rule| Array.wrap(rule)}.reduce(:+) || []
+        Array.wrap_nil(rules).map do |rule|
+          Array.wrap_nil(evaluate(rule))
+        end.reduce([], :+)
       end
     end
   end

data/lib/shiny_json_logic/operations/min.rb

@@ -6,7 +6,13 @@ module ShinyJsonLogic
       protected
 
       def run
-        rules.min
+        result = nil
+        rules.each do |rule|
+          Array.wrap_nil(evaluate(rule)).each do |val|
+            result = val if result.nil? || val < result
+          end
+        end
+        result
       end
     end
   end

data/lib/shiny_json_logic/operations/missing.rb

@@ -7,9 +7,15 @@ module ShinyJsonLogic
       protected
 
       def run
-        return rules unless data.is_a?(Hash) && rules.is_a?(Array)
+        items = Array.wrap_nil(rules)
+        keys = []
+        items.each do |rule|
+          evaluated = evaluate(rule)
+          keys.concat(Array.wrap_nil(evaluated))
+        end
+        return keys unless data.is_a?(Hash)
 
-        rules - deep_keys(data)
+        keys - deep_keys(data)
       end
 
       private

data/lib/shiny_json_logic/operations/missing_some.rb

@@ -7,11 +7,13 @@ module ShinyJsonLogic
       protected
 
       def run
-        return rules[1] unless data.is_a?(Hash) && rules.is_a?(Array)
+        min_required = evaluate(rules[0])
+        keys = Array.wrap_nil(evaluate(rules[1]))
+        return keys unless data.is_a?(Hash) && rules.is_a?(Array)
 
-        present = rules[1] & data.keys
-        ctx = { "rules" => rules[1], "data" => data, "errors" => errors }
-        present.size >= rules[0] ? [] : Missing.new(ctx).call["result"]
+        present = keys & data.keys
+        ctx = { "rules" => keys, "data" => data, "errors" => errors }
+        present.size >= min_required ? [] : Missing.new(ctx).call["result"]
       end
     end
   end

data/lib/shiny_json_logic/operations/modulo.rb

@@ -2,7 +2,6 @@ require "shiny_json_logic/operations/base"
 require "shiny_json_logic/numericals/with_error_handling"
 require "shiny_json_logic/numericals/numerify"
 
-
 module ShinyJsonLogic
   module Operations
     class Modulo < Base
@@ -12,10 +11,30 @@ module ShinyJsonLogic
       protected
 
       def run
-        return handle_no_operators if rules.size < 2
+        operands = Array.wrap_nil(rules)
+        return handle_no_operators if operands.empty?
 
         safe_arithmetic do
-          numerified.reduce { |a, b| a.remainder(b) }
+          result = nil
+          count = 0
+
+          each_operand(operands) do |num|
+            count += 1
+            result = result.nil? ? num : result.remainder(num)
+          end
+
+          return handle_no_operators if count < 2
+
+          result
+        end
+      end
+
+      private
+
+      def each_operand(operands)
+        operands.each do |rule|
+          evaluated = evaluate(rule)
+          yield numerify(evaluated)
         end
       end
     end

data/lib/shiny_json_logic/operations/none.rb

@@ -9,7 +9,7 @@ module ShinyJsonLogic
       def on_after(results)
         return true if results.empty?
 
-        results.all? { |res| res == false }
+        results.none? { |res| Truthy.call(res) }
       end
     end
   end

data/lib/shiny_json_logic/operations/not.rb

@@ -7,7 +7,8 @@ module ShinyJsonLogic
       protected
 
       def run
-        !Truthy.call(rules.first)
+        value = rules.is_a?(Array) ? rules.first : rules
+        !Truthy.call(evaluate(value))
       end
     end
   end

data/lib/shiny_json_logic/operations/or.rb

@@ -7,7 +7,12 @@ module ShinyJsonLogic
       protected
 
       def run
-        rules.find { |v| Truthy.call(v) } || rules.last
+        result = nil
+        rules.each do |rule|
+          result = evaluate(rule)
+          return result if Truthy.call(result)
+        end
+        result
       end
     end
   end

data/lib/shiny_json_logic/operations/product.rb

@@ -11,12 +11,39 @@ module ShinyJsonLogic
       protected
 
       def run
-        return 1 if rules.empty?
+        operands = Array.wrap_nil(rules)
+        return 1 if operands.empty?
 
         safe_arithmetic do
-          numerified.map(&:to_f).reduce(:*)
+          result = nil
+          count = 0
+
+          each_operand(operands) do |num|
+            return handle_nan if num.nil?
+            count += 1
+            result = result.nil? ? num.to_f : result * num.to_f
+          end
+
+          return 1 if count == 0
+
+          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/smaller.rb

@@ -1,12 +1,56 @@
 require "shiny_json_logic/operations/base"
+require "shiny_json_logic/numericals/with_error_handling"
+require "shiny_json_logic/numericals/numerify"
 
 module ShinyJsonLogic
   module Operations
     class Smaller < Base
+      include Numericals::WithErrorHandling
+      include Numericals::Numerify
+
       protected
 
       def run
-        rules.map(&:to_f).each_cons(2).all? { |a, b| a.to_f < b.to_f }
+        operands = Array.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
+      end
+
+      private
+
+      def compare(a, b)
+        # Arrays u objetos → NaN
+        return :nan if a.is_a?(Array) || a.is_a?(Hash) || b.is_a?(Array) || b.is_a?(Hash)
+
+        # Ambos strings → comparación lexicográfica
+        if a.is_a?(String) && b.is_a?(String)
+          return a <=> b
+        end
+
+        # Convertir a números para comparar
+        num_a = numerify_for_compare(a)
+        num_b = numerify_for_compare(b)
+        return :nan if num_a.nil? || num_b.nil?
+
+        num_a <=> num_b
+      end
+
+      def numerify_for_compare(value)
+        return value.to_f if value.is_a?(Numeric)
+        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) && numeric_string?(value)
+        nil # String no numérica
       end
     end
   end

data/lib/shiny_json_logic/operations/smaller_equal.rb

@@ -1,12 +1,56 @@
 require "shiny_json_logic/operations/base"
+require "shiny_json_logic/numericals/with_error_handling"
+require "shiny_json_logic/numericals/numerify"
 
 module ShinyJsonLogic
   module Operations
     class SmallerEqual < Base
+      include Numericals::WithErrorHandling
+      include Numericals::Numerify
+
       protected
 
       def run
-        rules.map(&:to_f).each_cons(2).all? { |a, b| a.to_f <= b.to_f }
+        operands = Array.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
+      end
+
+      private
+
+      def compare(a, b)
+        # Arrays u objetos → NaN
+        return :nan if a.is_a?(Array) || a.is_a?(Hash) || b.is_a?(Array) || b.is_a?(Hash)
+
+        # Ambos strings → comparación lexicográfica
+        if a.is_a?(String) && b.is_a?(String)
+          return a <=> b
+        end
+
+        # Convertir a números para comparar
+        num_a = numerify_for_compare(a)
+        num_b = numerify_for_compare(b)
+        return :nan if num_a.nil? || num_b.nil?
+
+        num_a <=> num_b
+      end
+
+      def numerify_for_compare(value)
+        return value.to_f if value.is_a?(Numeric)
+        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) && numeric_string?(value)
+        nil # String no numérica
       end
     end
   end

data/lib/shiny_json_logic/operations/strict_different.rb

@@ -1,12 +1,30 @@
 require "shiny_json_logic/operations/base"
-require "shiny_json_logic/operations/strict_equal"
+require "shiny_json_logic/numericals/with_error_handling"
 
 module ShinyJsonLogic
   module Operations
     class StrictDifferent < Base
-      def call
-        ctx = Operations::StrictEqual.new(context).call
-        {"result" => !ctx["result"], "data" => ctx["data"], "errors" => ctx["errors"]}
+      include Numericals::WithErrorHandling
+
+      protected
+
+      def run
+        operands = Array.wrap_nil(rules)
+        return handle_invalid_args if operands.length < 2
+
+        prev = cast(evaluate(operands[0]))
+        operands[1..].each do |rule|
+          curr = cast(evaluate(rule))
+          return false if curr == prev  # Si son iguales, !== es false
+          prev = curr
+        end
+        true  # Todos los pares consecutivos son diferentes
+      end
+
+      private
+
+      def cast(value)
+        value.is_a?(Numeric) ? value.to_f : value
       end
     end
   end

data/lib/shiny_json_logic/operations/strict_equal.rb

@@ -1,16 +1,28 @@
 require "shiny_json_logic/operations/base"
+require "shiny_json_logic/numericals/with_error_handling"
 
 module ShinyJsonLogic
   module Operations
     class StrictEqual < Base
+      include Numericals::WithErrorHandling
+
       protected
 
       def run
-        casted = rules.map do |value|
-          value.is_a?(Numeric) ? value.to_f : value
+        operands = Array.wrap_nil(rules)
+        return handle_invalid_args if operands.length < 2
+
+        first = cast(evaluate(operands[0]))
+        operands[1..].each do |rule|
+          return false unless cast(evaluate(rule)) == first
         end
+        true
+      end
+
+      private
 
-        casted.all? { |v| v == casted[0] }
+      def cast(value)
+        value.is_a?(Numeric) ? value.to_f : value
       end
     end
   end

data/lib/shiny_json_logic/operations/substring.rb

@@ -6,8 +6,9 @@ module ShinyJsonLogic
       protected
 
       def run
-        str, start = rules[0].to_s, rules[1].to_i
-        length = rules.fetch(2, str.length).to_i
+        str = evaluate(rules[0]).to_s
+        start = evaluate(rules[1]).to_i
+        length = rules[2] ? evaluate(rules[2]).to_i : str.length
         start += str.length if start < 0
         finish = length < 0 ? str.length + length : start + length
 

data/lib/shiny_json_logic/operations/subtraction.rb

@@ -11,19 +11,37 @@ module ShinyJsonLogic
       protected
 
       def run
+        operands = Array.wrap_nil(rules)
+        return handle_no_operators if operands.empty?
+
         safe_arithmetic do
-          return numerified.first * -1 if rules.size == 1
+          result = nil
+          count = 0
+
+          each_operand(operands) do |num|
+            count += 1
+            result = result.nil? ? num : result - num
+          end
 
-          numerified.reduce(:-)
+          return handle_no_operators if count == 0
+          return result * -1 if count == 1
+
+          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

data/lib/shiny_json_logic/operations/throw.rb

@@ -8,7 +8,7 @@ module ShinyJsonLogic
 
         error_type =
           if operation?(raw_value)
-            Engine.new(raw_value, data).call
+            evaluate(raw_value)
           else
             raw_value
           end