shiny_json_logic 0.2.8 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e05288f3f43187927c102d03ce0cd653bf8762dd7e0adc40b29d27e0c4f7984f
-  data.tar.gz: 4c6e781dec321b4f928b9b1d786c708ffe39662cc22676cc5ab7d8228dff8aa8
+  metadata.gz: f6c51d139183162260ba3b85195e9e8854da441bedad9ca5753785d2a781b9d4
+  data.tar.gz: 499f7e445cb8aadebb2397781c36b09722b688ee955994002963e38a0ce64b78
 SHA512:
-  metadata.gz: '0459cef93e4ce203e8ea1022c7bf7305aef736551e56bf3e8c47326ddcf95481232c788f5b3d5c96f25137df730b6cb5180ac3b7aadd696a1c4a0d9bea7e0aa3'
-  data.tar.gz: d3801f6f5cc0a0df664d829e352c934345305ce264a57bd39a7dd3f7e637963d402a0c7676e8c4f9fffa76fea7dffe6cca04d655bc38b79dfc781877faa616d5
+  metadata.gz: 5723ddd51acda1014b43b9f84e4ce2054a7b9fc1ea6e86fecc7d30742bd8b6f51309d7d220f15a7546713a151be503977cc7452bac1953a08c21fd6efbd9d285
+  data.tar.gz: bd2182abf594716ee39c4b892dae1079969f5d49402c258ad136d8b935460f9cd88d924dc6ffb8aa9336328578157f34eddbd04dc4ce8b7310c91cd4fbd18f48

data/.gitignore

@@ -21,3 +21,4 @@
 
 # Development context
 AGENTS_DEVELOPMENT.md
+DOCUMENTATION.md

data/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.2.11] - 2026-02-09
+### Changed
+- Removes monkey patches in favour of isolated modules.
+
+### Added
+- Supports hashes with string or symbol access indifferently (e.g. `{"a" => 1}` can be accessed with `:a` or `"a"`).
+
+## [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.11)
 
 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/comparisons/comparable.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "shiny_json_logic/numericals/numerify"
+
+module ShinyJsonLogic
+  module Comparisons
+    module Comparable
+      include Numericals::Numerify
+
+      private
+
+      def compare(a, b)
+        return :nan if a.is_a?(Array) || a.is_a?(Hash) || b.is_a?(Array) || b.is_a?(Hash)
+
+        if a.is_a?(String) && b.is_a?(String)
+          return a <=> b
+        end
+
+        num_a = numerify_for_comparison(a)
+        num_b = numerify_for_comparison(b)
+        return :nan if num_a.nil? || num_b.nil?
+
+        num_a <=> num_b
+      end
+
+      def numerify_for_comparison(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
+      end
+    end
+  end
+end

data/lib/shiny_json_logic/engine.rb

@@ -1,19 +1,10 @@
-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 +12,10 @@ module ShinyJsonLogic
         return rule if rule.empty?
 
         operation, args = rule.to_a.first
-        return rule unless operations.solvers.key?(operation)
+        operation_key = operation.to_s
+        return rule unless operations.key?(operation_key)
 
-        solve(operation, args)
+        operations.fetch(operation_key).new(args, scope_stack).call
       elsif rule.is_a?(Array)
         rule.map { |val| call(val) }
       else
@@ -34,22 +26,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 = []
+        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)
+            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
@@ -27,7 +25,7 @@ module ShinyJsonLogic
       private
 
       def each_operand
-        Array.wrap_nil(rules).each do |rule|
+        wrap_nil(rules).each do |rule|
           yield numerify(evaluate(rule))
         end
       end

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

@@ -1,42 +1,33 @@
 require "shiny_json_logic/truthy"
+require "shiny_json_logic/utils/array"
 
 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)
+      include Utils::Array
+
+      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 +45,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,13 +3,11 @@ 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|
+        wrap_nil(rules).each do |rule|
           evaluated = evaluate(rule)
-          Array.wrap_nil(evaluated).each { |v| result << v.to_s }
+          wrap_nil(evaluated).each { |v| result << v.to_s }
         end
         result.join
       end

data/lib/shiny_json_logic/operations/different.rb

@@ -1,19 +1,17 @@
 require "shiny_json_logic/operations/base"
 require "shiny_json_logic/numericals/with_error_handling"
-require "shiny_json_logic/numericals/numerify"
+require "shiny_json_logic/comparisons/comparable"
 
 module ShinyJsonLogic
   module Operations
     class Different < Base
       include Numericals::WithErrorHandling
-      include Numericals::Numerify
+      include Comparisons::Comparable
       raise_on_dynamic_args!
 
-      protected
-
-      def run
+      def call
         return handle_invalid_args if dynamic_args?
-        operands = Array.wrap_nil(rules)
+        operands = wrap_nil(rules)
         return handle_invalid_args if operands.length < 2
 
         prev = evaluate(operands[0])
@@ -21,39 +19,11 @@ module ShinyJsonLogic
           curr = evaluate(rule)
           result = compare(prev, curr)
           return handle_nan if result == :nan
-          return false if result == 0  # Si son iguales, != es false
+          return false if result == 0
           prev = curr
         end
-        true  # Todos los pares consecutivos son diferentes
-      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 directa
-        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
+        true
       end
     end
   end
-end
+end

data/lib/shiny_json_logic/operations/division.rb

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

data/lib/shiny_json_logic/operations/double_not.rb

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

data/lib/shiny_json_logic/operations/equal.rb

@@ -1,19 +1,17 @@
 require "shiny_json_logic/operations/base"
 require "shiny_json_logic/numericals/with_error_handling"
-require "shiny_json_logic/numericals/numerify"
+require "shiny_json_logic/comparisons/comparable"
 
 module ShinyJsonLogic
   module Operations
     class Equal < Base
       include Numericals::WithErrorHandling
-      include Numericals::Numerify
+      include Comparisons::Comparable
       raise_on_dynamic_args!
 
-      protected
-
-      def run
+      def call
         return handle_invalid_args if dynamic_args?
-        operands = Array.wrap_nil(rules)
+        operands = wrap_nil(rules)
         return handle_invalid_args if operands.length < 2
 
         first = evaluate(operands[0])
@@ -25,34 +23,6 @@ module ShinyJsonLogic
         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 directa
-        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
-end
+end

data/lib/shiny_json_logic/operations/exists.rb

@@ -3,12 +3,10 @@ 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|
+        wrap_nil(rules).each do |rule|
           segment = evaluate(rule)
           return false unless current.key?(segment)
           current = current[segment]

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)