shiny_json_logic 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e05288f3f43187927c102d03ce0cd653bf8762dd7e0adc40b29d27e0c4f7984f
-  data.tar.gz: 4c6e781dec321b4f928b9b1d786c708ffe39662cc22676cc5ab7d8228dff8aa8
+  metadata.gz: ecf7aea99599023d6adf2af12bbb99fe8a40d9d8bcce1c2410eb4a49337b08b6
+  data.tar.gz: 73944111a179b14d04e401351519c46400294b39e95571b3f744225915f759a6
 SHA512:
-  metadata.gz: '0459cef93e4ce203e8ea1022c7bf7305aef736551e56bf3e8c47326ddcf95481232c788f5b3d5c96f25137df730b6cb5180ac3b7aadd696a1c4a0d9bea7e0aa3'
-  data.tar.gz: d3801f6f5cc0a0df664d829e352c934345305ce264a57bd39a7dd3f7e637963d402a0c7676e8c4f9fffa76fea7dffe6cca04d655bc38b79dfc781877faa616d5
+  metadata.gz: 8676f95bd3ce898099859c0828fd56f0be608555ca89ecc3e133ffd4bedd435820c9ce58e15ecd2f4f44521514c1ddfbed3c8d235c4ca37acd1c87dc93bafc5c
+  data.tar.gz: 91d46fb710614bcf75ae1a198f21f9fabd06875f89c48224413c36a04668894c5ee2276374d1a0f6ca9a7d7f858c4f68b737386ffd2b6c9cb7e819b4b75a6e5a

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.2.9] - 2026-02-08
+### Added
+- New specific error classes: `Errors::InvalidArguments`, `Errors::NotANumber`, `Errors::UnknownOperator`
+  - All inherit from `Errors::Base`, so existing `rescue Errors::Base` will continue to work
+### Changed
+- Refactors max/min operators to use shared MinMaxCollection module
+- Eliminates code duplication between max.rb and min.rb
+
 ## [0.2.8] - 2026-02-07
 ### Changed
 - Improves error handling in try/throw/reduce operators

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    shiny_json_logic (0.2.8)
+    shiny_json_logic (0.2.9)
 
 GEM
   remote: https://rubygems.org/

data/bin/test.sh

@@ -7,8 +7,11 @@ cd "$ROOT_DIR"
 # Config
 COMPAT_REF="${COMPAT_REF:-main}"
 COMPAT_REPO="${COMPAT_REPO:-json-logic/compat-tables}"
+OFFICIAL_REF="${OFFICIAL_REF:-main}"
+OFFICIAL_REPO="${OFFICIAL_REPO:-json-logic/.github}"
 TMP_DIR="${TMP_DIR:-$ROOT_DIR/tmp}"
 SUITES_DIR="$TMP_DIR/compat-suites"
+OFFICIAL_DIR="$TMP_DIR/official-tests"
 
 # Helpers
 log() { printf "\n\033[1m%s\033[0m\n" "$*"; }
@@ -37,6 +40,22 @@ curl -fsSL "$ARCHIVE_URL" \
 
 log "Compat suites ready at: $SUITES_DIR"
 
+log "Fetching official tests from GitHub: $OFFICIAL_REPO@$OFFICIAL_REF"
+
+rm -rf "$OFFICIAL_DIR"
+mkdir -p "$OFFICIAL_DIR"
+
+OFFICIAL_URL="https://codeload.github.com/${OFFICIAL_REPO}/tar.gz/${OFFICIAL_REF}"
+
+# Extract only: .github-<ref>/tests -> tmp/official-tests
+curl -fsSL "$OFFICIAL_URL" \
+  | tar -xz \
+      --strip-components=2 \
+      -C "$OFFICIAL_DIR" \
+      ".github-${OFFICIAL_REF}/tests" 2>/dev/null \
+
+log "Official tests ready at: $OFFICIAL_DIR"
+
 log "Running compatibility suite"
 COMPAT_OUT="$TMP_DIR/compat-rspec.out"
 
@@ -75,3 +94,41 @@ cat > results/ruby.json <<EOF
 EOF
 
 echo "Compat: ${PASSED}/${TOTAL} (failures: ${FAILURES}, exit: ${COMPAT_EXIT})"
+
+# ---- Official tests (informational only, does not affect badge) ----
+log "Running official tests (informational)"
+OFFICIAL_OUT="$TMP_DIR/official-rspec.out"
+
+set +e
+OFFICIAL_TESTS_DIR="$OFFICIAL_DIR" bundle exec rspec spec/official_spec.rb | tee "$OFFICIAL_OUT"
+OFFICIAL_EXIT=${PIPESTATUS[0]}
+set -e
+
+# Parse totals from RSpec summary
+OFFICIAL_TOTAL=$(ruby -e '
+  s = STDIN.read
+  m = s.match(/(\d+)\s+examples?,\s+(\d+)\s+failures?/)
+  if m
+    puts m[1]
+  else
+    puts "0"
+  end
+' < "$OFFICIAL_OUT")
+
+OFFICIAL_FAILURES=$(ruby -e '
+  s = STDIN.read
+  m = s.match(/(\d+)\s+examples?,\s+(\d+)\s+failures?/)
+  if m
+    puts m[2]
+  else
+    puts "0"
+  end
+' < "$OFFICIAL_OUT")
+
+OFFICIAL_PASSED=$((OFFICIAL_TOTAL - OFFICIAL_FAILURES))
+
+echo "Official: ${OFFICIAL_PASSED}/${OFFICIAL_TOTAL} (failures: ${OFFICIAL_FAILURES}, exit: ${OFFICIAL_EXIT})"
+echo ""
+echo "=== Summary ==="
+echo "Compat (badge):  ${PASSED}/${TOTAL}"
+echo "Official (info): ${OFFICIAL_PASSED}/${OFFICIAL_TOTAL}"

data/lib/shiny_json_logic/engine.rb

@@ -1,19 +1,12 @@
 require "core_ext/array"
 require "core_ext/hash"
 require "shiny_json_logic/operator_solver"
-require "shiny_json_logic/scope_stack"
 
 module ShinyJsonLogic
   class Engine
-    attr_reader :errors
-
-    # Initialize with either:
-    # - Engine.new(rule, data) - creates a new scope_stack with data as root
-    # - Engine.new(rule, scope_stack: existing_stack) - uses existing scope_stack
-    def initialize(rule, data = nil, scope_stack: nil)
+    def initialize(rule, scope_stack)
       @rule = rule
-      @errors = []
-      @scope_stack = scope_stack || ScopeStack.new(data || {})
+      @scope_stack = scope_stack
     end
 
     def call(rule = self.rule)
@@ -21,9 +14,9 @@ module ShinyJsonLogic
         return rule if rule.empty?
 
         operation, args = rule.to_a.first
-        return rule unless operations.solvers.key?(operation)
+        return rule unless operations.key?(operation)
 
-        solve(operation, args)
+        operations.fetch(operation).new(args, scope_stack).call
       elsif rule.is_a?(Array)
         rule.map { |val| call(val) }
       else
@@ -34,22 +27,9 @@ module ShinyJsonLogic
     private
 
     attr_reader :rule, :scope_stack
-    attr_writer :errors
-
-    def solve(operation, args)
-      context = {
-        "rules" => args,
-        "errors" => errors,
-        "scope_stack" => scope_stack
-      }
-      result, errors = operations.solvers.fetch(operation).new(context).call.values_at("result", "errors")
-      self.errors = [*self.errors, *errors].uniq
-
-      result
-    end
 
     def operations
-      @operations ||= OperatorSolver.new
+      @operations ||= OperatorSolver.new.solvers
     end
   end
 end

data/lib/shiny_json_logic/errors/base.rb

@@ -1,15 +1,11 @@
-require "securerandom"
-
 module ShinyJsonLogic
   module Errors
     class Base < StandardError
-      attr_reader :type, :id
-      attr_accessor :panic
+      attr_reader :type
 
       def initialize(type: nil)
         super(type)
         @type = type
-        @id = "shiny_error_#{SecureRandom.uuid}"
       end
 
       def payload

data/lib/shiny_json_logic/errors/invalid_arguments.rb

@@ -0,0 +1,11 @@
+require "shiny_json_logic/errors/base"
+
+module ShinyJsonLogic
+  module Errors
+    class InvalidArguments < Base
+      def initialize
+        super(type: "Invalid Arguments")
+      end
+    end
+  end
+end

data/lib/shiny_json_logic/errors/not_a_number.rb

@@ -0,0 +1,11 @@
+require "shiny_json_logic/errors/base"
+
+module ShinyJsonLogic
+  module Errors
+    class NotANumber < Base
+      def initialize
+        super(type: "NaN")
+      end
+    end
+  end
+end

data/lib/shiny_json_logic/errors/unknown_operator.rb

@@ -0,0 +1,11 @@
+require "shiny_json_logic/errors/base"
+
+module ShinyJsonLogic
+  module Errors
+    class UnknownOperator < Base
+      def initialize
+        super(type: "Unknown Operator")
+      end
+    end
+  end
+end

data/lib/shiny_json_logic/numericals/min_max_collection.rb

@@ -0,0 +1,31 @@
+require "shiny_json_logic/errors/invalid_arguments"
+
+module ShinyJsonLogic
+  module Numericals
+    module MinMaxCollection
+      private
+
+      def collect_numeric_values
+        values = collect_values
+        raise Errors::InvalidArguments if values.empty?
+        raise Errors::InvalidArguments unless values.all? { |v| v.is_a?(Numeric) }
+        values
+      end
+
+      def collect_values
+        result = []
+        Array.wrap_nil(rules).each do |rule|
+          evaluated = evaluate(rule)
+          # If rule was an operation (Hash), expand the result array
+          # If rule was a literal array, it's invalid (will fail numeric check)
+          if operation?(rule)
+            Array.wrap_nil(evaluated).each { |val| result << val }
+          else
+            result << evaluated
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/shiny_json_logic/numericals/with_error_handling.rb

@@ -1,4 +1,6 @@
 require "shiny_json_logic/errors/base"
+require "shiny_json_logic/errors/not_a_number"
+require "shiny_json_logic/errors/invalid_arguments"
 
 module ShinyJsonLogic
   module Numericals
@@ -14,20 +16,12 @@ module ShinyJsonLogic
       end
 
       def handle_nan
-        error = ShinyJsonLogic::Errors::Base.new(type: "NaN")
-        self.errors << error
-        error.id
+        raise Errors::NotANumber
       end
 
       def handle_invalid_args
-        error = ShinyJsonLogic::Errors::Base.new(type: "Invalid Arguments")
-        self.errors << error
-        error.id
+        raise Errors::InvalidArguments
       end
-
-      # Alias for backward compatibility
-      alias_method :handle_invalid_operand, :handle_nan
-      alias_method :handle_no_operators, :handle_invalid_args
     end
   end
 end

data/lib/shiny_json_logic/operations/addition.rb

@@ -8,9 +8,7 @@ module ShinyJsonLogic
       include Numericals::WithErrorHandling
       include Numericals::Numerify
 
-      protected
-
-      def run
+      def call
         safe_arithmetic do
           result = 0.0
           count = 0

data/lib/shiny_json_logic/operations/and.rb

@@ -8,9 +8,7 @@ module ShinyJsonLogic
       include Numericals::WithErrorHandling
       raise_on_dynamic_args!
 
-      protected
-
-      def run
+      def call
         return handle_invalid_args if dynamic_args?
         return handle_invalid_args unless rules.is_a?(Array)
         return false if rules.empty?

data/lib/shiny_json_logic/operations/base.rb

@@ -3,40 +3,28 @@ require "shiny_json_logic/truthy"
 module ShinyJsonLogic
   module Operations
     class Base
-      def initialize(context)
-        @context = context
-        @rules, @errors, @scope_stack = @context.values_at("rules", "errors", "scope_stack")
-        @dynamic_args = operation?(@rules)
-        @rules = pre_process(@rules)
+      def initialize(rules, scope_stack)
+        @scope_stack = scope_stack
+        @dynamic_args = operation?(rules)
+        @rules = pre_process(rules)
       end
 
       def call
-        deliver run
+        raise NotImplementedError
       end
 
       protected
 
-      attr_reader :context, :scope_stack
-      attr_accessor :rules, :errors
+      attr_reader :scope_stack
+      attr_accessor :rules
 
       # Access current data through scope_stack
       def data
         scope_stack.current
       end
 
-      def run
-        raise NotImplementedError
-      end
-
-      def deliver(result = nil)
-        {"result" => result, "errors" => self.errors}
-      end
-
       def evaluate(rule)
-        engine = Engine.new(rule, scope_stack: scope_stack)
-        result = engine.call
-        self.errors = [*errors, *engine.errors].uniq
-        result
+        Engine.new(rule, scope_stack).call
       end
 
       def dynamic_args?
@@ -54,15 +42,14 @@ module ShinyJsonLogic
       private
 
       def pre_process(rules)
-        if operation?(rules)
-          evaluate(rules)
-        else
-          rules
-        end
+        return evaluate(rules) if operation?(rules)
+
+        rules
       end
 
       def operation?(value)
         return false unless value.is_a?(Hash) && !value.empty?
+
         OperatorSolver.new.operation?(value)
       end
     end

data/lib/shiny_json_logic/operations/coalesce.rb

@@ -3,9 +3,7 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Coalesce < Base
-      protected
-
-      def run
+      def call
         rules.each do |rule|
           result = evaluate(rule)
           return result unless result.nil?

data/lib/shiny_json_logic/operations/concatenation.rb

@@ -3,9 +3,7 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Concatenation < Base
-      protected
-
-      def run
+      def call
         result = []
         Array.wrap_nil(rules).each do |rule|
           evaluated = evaluate(rule)

data/lib/shiny_json_logic/operations/different.rb

@@ -9,9 +9,7 @@ module ShinyJsonLogic
       include Numericals::Numerify
       raise_on_dynamic_args!
 
-      protected
-
-      def run
+      def call
         return handle_invalid_args if dynamic_args?
         operands = Array.wrap_nil(rules)
         return handle_invalid_args if operands.length < 2

data/lib/shiny_json_logic/operations/division.rb

@@ -8,9 +8,7 @@ module ShinyJsonLogic
       include Numericals::WithErrorHandling
       include Numericals::Numerify
 
-      protected
-
-      def run
+      def call
         operands = Array.wrap_nil(rules)
         return handle_invalid_args if operands.empty?
 

data/lib/shiny_json_logic/operations/double_not.rb

@@ -4,9 +4,7 @@ require "shiny_json_logic/truthy"
 module ShinyJsonLogic
   module Operations
     class DoubleNot < Base
-      protected
-
-      def run
+      def call
         value = Array.wrap_nil(rules).first
         !!Truthy.call(evaluate(value))
       end

data/lib/shiny_json_logic/operations/equal.rb

@@ -9,9 +9,7 @@ module ShinyJsonLogic
       include Numericals::Numerify
       raise_on_dynamic_args!
 
-      protected
-
-      def run
+      def call
         return handle_invalid_args if dynamic_args?
         operands = Array.wrap_nil(rules)
         return handle_invalid_args if operands.length < 2

data/lib/shiny_json_logic/operations/exists.rb

@@ -3,9 +3,7 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Exists < Base
-      protected
-
-      def run
+      def call
         current = data
 
         Array.wrap_nil(rules).each do |rule|

data/lib/shiny_json_logic/operations/filter.rb

@@ -10,8 +10,7 @@ module ShinyJsonLogic
       private
 
       def on_each(item)
-        engine = Engine.new(filter, scope_stack: scope_stack)
-        [Truthy.call(engine.call) ? item : nil, engine]
+        Truthy.call(Engine.new(filter, scope_stack).call) ? item : nil
       end
 
       def on_after(results)

data/lib/shiny_json_logic/operations/greater.rb

@@ -9,9 +9,7 @@ module ShinyJsonLogic
       include Numericals::Numerify
       raise_on_dynamic_args!
 
-      protected
-
-      def run
+      def call
         return handle_invalid_args if dynamic_args?
         operands = Array.wrap_nil(rules)
         return handle_invalid_args if operands.length < 2

data/lib/shiny_json_logic/operations/greater_equal.rb

@@ -9,9 +9,7 @@ module ShinyJsonLogic
       include Numericals::Numerify
       raise_on_dynamic_args!
 
-      protected
-
-      def run
+      def call
         return handle_invalid_args if dynamic_args?
         operands = Array.wrap_nil(rules)
         return handle_invalid_args if operands.length < 2

data/lib/shiny_json_logic/operations/if.rb

@@ -8,26 +8,21 @@ module ShinyJsonLogic
       include Numericals::WithErrorHandling
 
       # Skip pre_process - spec requires static array, dynamic args should error
-      def initialize(context)
-        @context = context
-        @rules, @errors, @scope_stack = context.values_at("rules", "errors", "scope_stack")
+      def initialize(rules, scope_stack)
+        @rules = rules
+        @scope_stack = scope_stack
       end
 
-      protected
-
-      def run
+      def call
         return handle_invalid_args unless rules.is_a?(Array)
 
         rules.each_slice(2) do |condition_rule, value_rule|
           condition_result = evaluate(condition_rule)
-          return condition_result if error?(condition_result)
           return condition_result if value_rule.nil?
 
           next unless Truthy.call(condition_result)
 
-          value_result = evaluate(value_rule)
-          return value_result if error?(value_result)
-          return value_result
+          return evaluate(value_rule)
         end
 
         nil
@@ -36,14 +31,7 @@ module ShinyJsonLogic
       private
 
       def evaluate(rule)
-        engine = Engine.new(rule, scope_stack: scope_stack)
-        result = engine.call
-        self.errors = [*errors, *engine.errors] if error?(result)
-        result
-      end
-
-      def error?(result)
-        result.is_a?(String) && result.match?(Try::SHINY_ERROR_PATTERN)
+        Engine.new(rule, scope_stack).call
       end
     end
   end

data/lib/shiny_json_logic/operations/inclusion.rb

@@ -3,9 +3,7 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Inclusion < Base
-      protected
-
-      def run
+      def call
         needle = evaluate(rules.first)
         haystack = evaluate(rules.last)
         haystack.include?(needle)

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

@@ -4,7 +4,7 @@ module ShinyJsonLogic
   module Operations
     module Iterable
       class Base < Operations::Base
-        def initialize(context)
+        def initialize(rules, scope_stack)
           super
 
           return handle_nil if dynamic_args?
@@ -20,39 +20,31 @@ module ShinyJsonLogic
         end
 
         def call
-          return deliver if errors.any?
-
-          deliver run
-        end
-
-        protected
-
-        def run
           on_before
 
-          collection.each_with_index.each_with_object([]) do |(item, index), results|
+          results = collection.each_with_index.each_with_object([]) do |(item, index), results|
             on_before_each(item, index)
-            solved, solver = on_each(item)
-            results << solved
-            if solved.is_a?(String) && solved.match?(Try::SHINY_ERROR_PATTERN)
-              # Propagate errors before breaking
-              self.errors = [*self.errors, *solver.errors]
-              # Clean up scopes pushed by on_before_each
+            begin
+              solved = on_each(item)
+              results << solved
+              on_after_each
+            rescue => e
+              # Clean up scopes before re-raising
               scope_stack.pop  # item scope
               scope_stack.pop  # iterator context scope
-              break results
+              raise e
             end
-            on_after_each(solved, solver)
-          end.then do |results|
-            on_after(results)
           end
+
+          on_after(results)
         end
 
+        protected
+
         private
 
         def on_each(_item)
-          engine = Engine.new(filter, scope_stack: scope_stack)
-          [engine.call, engine]
+          Engine.new(filter, scope_stack).call
         end
 
         def on_before_each(item, index = 0)
@@ -64,30 +56,22 @@ module ShinyJsonLogic
           scope_stack.push(item, index: index)
         end
 
-        def on_after_each(_solved, solver)
+        def on_after_each
           # Pop the item scope
           scope_stack.pop
           # Pop the iterator context scope
           scope_stack.pop
-          self.errors = [*self.errors, *solver.errors]
         end
 
         def on_before
         end
 
         def on_after(results)
-          # If last result is an error, return it (not the array)
-          if results.last.is_a?(String) && results.last.match?(Try::SHINY_ERROR_PATTERN)
-            return results.last
-          end
           results
         end
 
         def handle_nil
-          error = Errors::Base.new(type: "Invalid Arguments")
-          self.errors = [error]
-
-          error.id
+          raise Errors::InvalidArguments
         end
 
         def setup_collection(collection)

data/lib/shiny_json_logic/operations/max.rb

@@ -1,18 +1,13 @@
 require "shiny_json_logic/operations/base"
+require "shiny_json_logic/numericals/min_max_collection"
 
 module ShinyJsonLogic
   module Operations
     class Max < Base
-      protected
+      include Numericals::MinMaxCollection
 
-      def run
-        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
+      def call
+        collect_numeric_values.max
       end
     end
   end

data/lib/shiny_json_logic/operations/merge.rb

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

data/lib/shiny_json_logic/operations/min.rb

@@ -1,18 +1,13 @@
 require "shiny_json_logic/operations/base"
+require "shiny_json_logic/numericals/min_max_collection"
 
 module ShinyJsonLogic
   module Operations
     class Min < Base
-      protected
+      include Numericals::MinMaxCollection
 
-      def run
-        result = nil
-        rules.each do |rule|
-          Array.wrap_nil(evaluate(rule)).each do |val|
-            result = val if result.nil? || val < result
-          end
-        end
-        result
+      def call
+        collect_numeric_values.min
       end
     end
   end

data/lib/shiny_json_logic/operations/missing.rb

@@ -4,9 +4,7 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Missing < Base
-      protected
-
-      def run
+      def call
         items = Array.wrap_nil(rules)
         keys = []
         items.each do |rule|

data/lib/shiny_json_logic/operations/missing_some.rb

@@ -4,16 +4,13 @@ require "shiny_json_logic/operations/missing"
 module ShinyJsonLogic
   module Operations
     class MissingSome < Missing
-      protected
-
-      def run
+      def call
         min_required = evaluate(rules[0])
         keys = Array.wrap_nil(evaluate(rules[1]))
         return keys unless data.is_a?(Hash) && rules.is_a?(Array)
 
         present = keys & data.keys
-        ctx = { "rules" => keys, "errors" => errors, "scope_stack" => scope_stack }
-        present.size >= min_required ? [] : Missing.new(ctx).call["result"]
+        present.size >= min_required ? [] : Missing.new(keys, scope_stack).call
       end
     end
   end

data/lib/shiny_json_logic/operations/modulo.rb

@@ -8,11 +8,9 @@ module ShinyJsonLogic
       include Numericals::WithErrorHandling
       include Numericals::Numerify
 
-      protected
-
-      def run
+      def call
         operands = Array.wrap_nil(rules)
-        return handle_no_operators if operands.empty?
+        return handle_invalid_args if operands.empty?
 
         safe_arithmetic do
           result = nil
@@ -23,7 +21,7 @@ module ShinyJsonLogic
             result = result.nil? ? num : result.remainder(num)
           end
 
-          return handle_no_operators if count < 2
+          return handle_invalid_args if count < 2
 
           result
         end

data/lib/shiny_json_logic/operations/not.rb

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

data/lib/shiny_json_logic/operations/or.rb

@@ -8,9 +8,7 @@ module ShinyJsonLogic
       include Numericals::WithErrorHandling
       raise_on_dynamic_args!
 
-      protected
-
-      def run
+      def call
         return handle_invalid_args if dynamic_args?
         return handle_invalid_args unless rules.is_a?(Array)
         return false if rules.empty?

data/lib/shiny_json_logic/operations/preserve.rb

@@ -3,16 +3,18 @@ require "shiny_json_logic/truthy"
 module ShinyJsonLogic
   module Operations
     class Preserve < Iterable::Base
-      def initialize(context)
-        super
-        @collection = context["rules"] || []
+      def initialize(rules, scope_stack)
+        @collection = Array.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 = Engine.new(item, scope_stack: scope_stack)
-        [engine.call, engine]
+        Engine.new(item, scope_stack).call
       end
 
       def on_after(results)
@@ -26,9 +28,8 @@ module ShinyJsonLogic
         # Don't push to scope stack
       end
 
-      def on_after_each(_solved, solver)
+      def on_after_each
         # Don't pop from scope stack
-        self.errors = [*self.errors, *solver.errors]
       end
     end
   end

data/lib/shiny_json_logic/operations/product.rb

@@ -8,9 +8,7 @@ module ShinyJsonLogic
       include Numericals::WithErrorHandling
       include Numericals::Numerify
 
-      protected
-
-      def run
+      def call
         operands = Array.wrap_nil(rules)
         return 1 if operands.empty?
 

data/lib/shiny_json_logic/operations/reduce.rb

@@ -8,12 +8,12 @@ module ShinyJsonLogic
       include Numericals::WithErrorHandling
       raise_on_dynamic_args!
 
-      def initialize(context)
+      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
-        return if errors.any?
-
         # Evaluate the initial accumulator value (third argument)
-        @accumulator = Engine.new(context.dig("rules", 2), scope_stack: scope_stack).call
+        @accumulator = Engine.new(initial_accumulator_rule, scope_stack).call
       end
 
       private
@@ -31,9 +31,7 @@ module ShinyJsonLogic
       end
 
       def on_each(_item)
-        engine = Engine.new(filter, scope_stack: scope_stack)
-        self.accumulator = engine.call
-        [self.accumulator, engine]
+        self.accumulator = Engine.new(filter, scope_stack).call
       end
 
       def on_after(_results)

data/lib/shiny_json_logic/operations/smaller.rb

@@ -9,9 +9,7 @@ module ShinyJsonLogic
       include Numericals::Numerify
       raise_on_dynamic_args!
 
-      protected
-
-      def run
+      def call
         return handle_invalid_args if dynamic_args?
         operands = Array.wrap_nil(rules)
         return handle_invalid_args if operands.length < 2

data/lib/shiny_json_logic/operations/smaller_equal.rb

@@ -9,9 +9,7 @@ module ShinyJsonLogic
       include Numericals::Numerify
       raise_on_dynamic_args!
 
-      protected
-
-      def run
+      def call
         return handle_invalid_args if dynamic_args?
         operands = Array.wrap_nil(rules)
         return handle_invalid_args if operands.length < 2

data/lib/shiny_json_logic/operations/strict_different.rb

@@ -7,9 +7,7 @@ module ShinyJsonLogic
       include Numericals::WithErrorHandling
       raise_on_dynamic_args!
 
-      protected
-
-      def run
+      def call
         return handle_invalid_args if dynamic_args?
         operands = Array.wrap_nil(rules)
         return handle_invalid_args if operands.length < 2

data/lib/shiny_json_logic/operations/strict_equal.rb

@@ -7,9 +7,7 @@ module ShinyJsonLogic
       include Numericals::WithErrorHandling
       raise_on_dynamic_args!
 
-      protected
-
-      def run
+      def call
         return handle_invalid_args if dynamic_args?
         operands = Array.wrap_nil(rules)
         return handle_invalid_args if operands.length < 2

data/lib/shiny_json_logic/operations/substring.rb

@@ -3,9 +3,7 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Substring < Base
-      protected
-
-      def run
+      def call
         str = evaluate(rules[0]).to_s
         start = evaluate(rules[1]).to_i
         length = rules[2] ? evaluate(rules[2]).to_i : str.length

data/lib/shiny_json_logic/operations/subtraction.rb

@@ -8,11 +8,9 @@ module ShinyJsonLogic
       include Numericals::WithErrorHandling
       include Numericals::Numerify
 
-      protected
-
-      def run
+      def call
         operands = Array.wrap_nil(rules)
-        return handle_no_operators if operands.empty?
+        return handle_invalid_args if operands.empty?
 
         safe_arithmetic do
           result = nil
@@ -23,7 +21,7 @@ module ShinyJsonLogic
             result = result.nil? ? num : result - num
           end
 
-          return handle_no_operators if count == 0
+          return handle_invalid_args if count == 0
           return result * -1 if count == 1
 
           result

data/lib/shiny_json_logic/operations/throw.rb

@@ -3,7 +3,7 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Throw < Base
-      def run
+      def call
         raw_value = rules.is_a?(Array) ? rules[0] : rules
 
         error_type =
@@ -17,10 +17,9 @@ module ShinyJsonLogic
         extracted_type = self.data["type"] if extracted_type.nil?
         self.data["type"] = extracted_type unless extracted_type.nil?
 
-        error = ShinyJsonLogic::Errors::Base.new(type: extracted_type)
-        errors.push error
+        error = Errors::Base.new(type: extracted_type)
 
-        error.id
+        raise error
       end
     end
   end

data/lib/shiny_json_logic/operations/try.rb

@@ -3,48 +3,43 @@ require "core_ext/array"
 module ShinyJsonLogic
   module Operations
     class Try < Base
-      SHINY_ERROR_PATTERN = /shiny_error_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i
-
-      protected
-
-      def run
+      def call
         items = Array.wrap_nil(rules)
         last_error = nil
 
         items.each do |item|
           # If previous item was an error, switch context to error payload
-          # Push two levels to match iterator convention:
-          # - Level 1: empty context (like iterator's index context)
-          # - Level 0: error payload (like iterator's current item)
           if last_error
             scope_stack.push({})  # intermediate level for [[1]] access
             scope_stack.push(last_error.payload)
           end
 
-          engine = Engine.new(item, scope_stack: scope_stack)
-          result = engine.call
+          begin
+            engine = Engine.new(item, scope_stack)
+            result = engine.call
 
-          # Pop error contexts if we pushed them
-          if last_error
-            scope_stack.pop  # error payload
-            scope_stack.pop  # intermediate level
-          end
+            # Pop error contexts if we pushed them
+            if last_error
+              scope_stack.pop  # error payload
+              scope_stack.pop  # intermediate level
+            end
 
-          # Check if result is an error
-          if result.is_a?(String) && result.match?(SHINY_ERROR_PATTERN)
-            # Find the error object
-            last_error = engine.errors.find { |e| e.id == result }
-          else
             # Found a valid result, return it
             return result
+          rescue ShinyJsonLogic::Errors::Base => e
+            # Pop error contexts if we pushed them
+            if last_error
+              scope_stack.pop  # error payload
+              scope_stack.pop  # intermediate level
+            end
+
+            last_error = e
+            # Don't add to errors array - we're handling it
           end
         end
 
         # All items were errors, re-raise the last one
-        if last_error
-          self.errors = [last_error]
-          last_error.id
-        end
+        raise last_error if last_error
       end
     end
   end

data/lib/shiny_json_logic/operations/val.rb

@@ -3,9 +3,7 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Val < Base
-      protected
-
-      def run
+      def call
         raw_keys = Array.wrap_nil(rules)
         
         # {"val": []} or {"val": null} - return current scope

data/lib/shiny_json_logic/operations/var.rb

@@ -4,9 +4,7 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Var < Base
-      protected
-
-      def run
+      def call
         items = Array.wrap_nil(rules)
         key = evaluate(items[0])
         default = items[1] ? evaluate(items[1]) : nil

data/lib/shiny_json_logic/version.rb

@@ -1,3 +1,3 @@
 module ShinyJsonLogic
-  VERSION = "0.2.8"
+  VERSION = "0.2.9"
 end

data/lib/shiny_json_logic.rb

@@ -1,13 +1,43 @@
 require "shiny_json_logic/version"
 require "shiny_json_logic/engine"
+require "shiny_json_logic/errors/base"
+require "shiny_json_logic/errors/invalid_arguments"
+require "shiny_json_logic/errors/not_a_number"
+require "shiny_json_logic/errors/unknown_operator"
+require "shiny_json_logic/operator_solver"
+require "shiny_json_logic/scope_stack"
 
 module ShinyJsonLogic
   def self.apply(rule, data = {})
-    engine = Engine.new(rule, data)
-    engine.call.tap do |result|
-      raise engine.errors.shift if engine.errors.any?
+    validate_operators!(rule)
+    
+    scope_stack = ScopeStack.new(data || {})
+    engine = Engine.new(rule, scope_stack)
+    engine.call
+  end
 
-      result
+  # Validates that all operations in the rule tree use known operators
+  def self.validate_operators!(rule)
+    case rule
+    when Hash
+      return if rule.empty?
+      
+      # Multi-key hashes are invalid
+      if rule.size > 1
+        raise Errors::UnknownOperator
+      end
+      
+      operation, args = rule.first
+      
+      # Check if operation is known
+      unless OperatorSolver.new.solvers.key?(operation)
+        raise Errors::UnknownOperator
+      end
+      
+      # Recursively validate args
+      validate_operators!(args)
+    when Array
+      rule.each { |item| validate_operators!(item) }
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shiny_json_logic
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
 platform: ruby
 authors:
 - Luis Moyano
@@ -131,6 +131,10 @@ files:
 - lib/shiny_json_logic.rb
 - lib/shiny_json_logic/engine.rb
 - lib/shiny_json_logic/errors/base.rb
+- lib/shiny_json_logic/errors/invalid_arguments.rb
+- lib/shiny_json_logic/errors/not_a_number.rb
+- lib/shiny_json_logic/errors/unknown_operator.rb
+- lib/shiny_json_logic/numericals/min_max_collection.rb
 - lib/shiny_json_logic/numericals/numerify.rb
 - lib/shiny_json_logic/numericals/with_error_handling.rb
 - lib/shiny_json_logic/operations/addition.rb