shiny_json_logic 0.2.6 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c094c662a616d343c0d045d0c8da1173fb1f982c19b709ffc1e9c8550813092
-  data.tar.gz: 872f71f3d52d7dc6d16a98e2fbf97cd50c07d9d901f7a2ac29ec831a86aa2621
+  metadata.gz: e05288f3f43187927c102d03ce0cd653bf8762dd7e0adc40b29d27e0c4f7984f
+  data.tar.gz: 4c6e781dec321b4f928b9b1d786c708ffe39662cc22676cc5ab7d8228dff8aa8
 SHA512:
-  metadata.gz: d28d16b67aaa1aa1435e2babfc2bf4b600c059ee896d863d85d1ba5460397a6eab0c4825575046ca72d0b1f804176710817bedc47d576eb84859e58af6996853
-  data.tar.gz: '099460668bdd8641e3f37d2ece887eca7100ccf3d7e5ade02c57317c2676a163dcf4ed2aedb417037f6779d133051ca07a7b785e98b3f5661b83259edfb2b0a3'
+  metadata.gz: '0459cef93e4ce203e8ea1022c7bf7305aef736551e56bf3e8c47326ddcf95481232c788f5b3d5c96f25137df730b6cb5180ac3b7aadd696a1c4a0d9bea7e0aa3'
+  data.tar.gz: d3801f6f5cc0a0df664d829e352c934345305ce264a57bd39a7dd3f7e637963d402a0c7676e8c4f9fffa76fea7dffe6cca04d655bc38b79dfc781877faa616d5

data/.gitignore

@@ -18,3 +18,6 @@
 
 # Gem
 *.gem
+
+# Development context
+AGENTS_DEVELOPMENT.md

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.2.8] - 2026-02-07
+### Changed
+- Improves error handling in try/throw/reduce operators
+- Fixes error propagation in iterators (map/filter/all/some/none)
+- Compatibility improved from 98.3% to 99.7%
+
+## [0.2.7] - 2026-02-05
+### Changed
+- Refactors internal architecture to always enable lazy loading
+- Improves compatibility of arithmetic operators
+- Improves compatibility of logical operators
+
 ## [0.2.6] - 2026-02-02
 ### Changed
 - Fixes bug with iterable when rules are empty

data/Gemfile.lock

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

data/README.md

@@ -4,7 +4,7 @@
 [![Gem Version](https://badge.fury.io/rb/shiny_json_logic.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/shiny_json_logic)
 ![Ruby](https://img.shields.io/badge/ruby-%3E%3D%202.7-brightgreen)
 
-> **A boring, correct and production-ready JSON Logic implementation for Ruby. ✨** 
+> **A boring, correct and production-ready JSONLogic implementation for Ruby. ✨** 
 
 **ShinyJsonLogic** is a **pure Ruby**, **zero-dependency** JSON Logic implementation, designed to offer a reliable and well-tested engine for Ruby applications.
 
@@ -17,11 +17,15 @@ This gem focuses on predictable behavior, strict spec alignment, high compatibil
 - 🧩 **Zero runtime dependencies** (stdlib-only). Just plug & play!
 - 🕰️ **Ruby 2.7+ compatible**, one of the lowest minimum versions supported in the Ruby ecosystem.
 - 🔧 **Actively maintained** and continuously improved.
-- 📊 **Highest JSON Logic compatibility in the Ruby ecosystem**, as measured against the official test suites.
+- 📊 **Highest JSONLogic compatibility in the Ruby ecosystem**, as measured against the official test suites.
 - ⭐ **Only Ruby implementation supporting the latest standard operators** (`val`, `exists`, `??`, `try`, `throw`)
 
 If you want JSON Logic to *just work* in Ruby, this is the safe default.
 
+---
+# Test it for yourself!
+Try it out in the sandbox at [jsonlogicruby.com](https://jsonlogicruby.com)
+
 ---
 
 ## Installation
@@ -52,6 +56,38 @@ require "shiny_json_logic"
 
 ---
 
+## Migrating from json-logic-ruby
+
+If you're currently using [json-logic-ruby](https://github.com/bhgames/json-logic-ruby), migration is seamless.
+
+ShinyJsonLogic provides `JsonLogic` and `JSONLogic` as aliases, so you only need to swap the gem in your Gemfile:
+
+```diff
+- gem "json-logic-ruby"
++ gem "shiny_json_logic"
+```
+
+Your existing code will work without changes:
+
+```ruby
+require "shiny_json_logic"
+
+# Both of these work exactly as before:
+JsonLogic.apply(rule, data)
+JSONLogic.apply(rule, data)
+
+# Or use the new module name:
+ShinyJsonLogic.apply(rule, data)
+```
+
+**Why should you give us a chance?**
+- 🐛 Better spec compliance and fewer edge-case bugs
+- ✨ Support for new operators (`val`, `exists`, `??`, `try`, `throw`, `preserve`)
+- 🔧 Actively maintained
+- 🧪 Higher test coverage against official JSONLogic test suites
+
+---
+
 ## Usage
 
 Basic usage is intentionally simple:
@@ -156,7 +192,7 @@ Install locally:
 ```bash
 bundle install
 ```
-How to run the compatibility tests:
+How to run the compatibility test suite:
 
 ```bash
 bin/test.sh

data/badges/compat.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
   "label": "compat",
-  "message": "83.9% (945/1126)",
-  "color": "red"
+  "message": "99.7% (1123/1126)",
+  "color": "green"
 }

data/lib/core_ext/array.rb

@@ -6,6 +6,11 @@ class Array
     [object]
   end
 
+  def self.wrap_nil(object)
+    return [nil] if object.nil?
+    wrap(object)
+  end
+
   def deep_fetch(index, default = nil)
     indexes = index.to_s.split('.').map(&:to_i)
     value = dig(*indexes) rescue default

data/lib/shiny_json_logic/engine.rb

@@ -1,37 +1,31 @@
 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
 
-    def initialize(rule, data = {})
+    # 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)
       @rule = rule
-      @data = data || {}
       @errors = []
+      @scope_stack = scope_stack || ScopeStack.new(data || {})
     end
 
-    def call(rule = self.rule, data = self.data)
+    def call(rule = self.rule)
       if rule.is_a?(Hash)
         return rule if rule.empty?
 
-        operation, raw_args = rule.to_a.first
-        if operations.collection_solvers.key?(operation)
-          solve(operation, raw_args, data)
-        else
-          evaluated_args =
-            if raw_args.is_a?(Array)
-              raw_args.map { |val| call(val, data) }
-            else
-              call = call(raw_args, data)
-              call.is_a?(Array) ? call : [call(raw_args, data)]
-            end
-
-          solve(operation, evaluated_args, data)
-        end
+        operation, args = rule.to_a.first
+        return rule unless operations.solvers.key?(operation)
+
+        solve(operation, args)
       elsif rule.is_a?(Array)
-        rule.map { |val| call(val, data) }
+        rule.map { |val| call(val) }
       else
         rule
       end
@@ -39,15 +33,17 @@ module ShinyJsonLogic
 
     private
 
-    attr_reader :rule
-    attr_accessor :data
+    attr_reader :rule, :scope_stack
     attr_writer :errors
 
-    def solve(operation, args, initial_data)
-      context = {"rules" => args, "data" => initial_data, "errors" => errors}
-      result, data, errors = operations.solvers.fetch(operation).new(context).call.values_at("result", "data", "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
-      self.data.merge data if self.data.is_a?(Hash) && data.is_a?(Hash)
 
       result
     end

data/lib/shiny_json_logic/numericals/numerify.rb

@@ -1,25 +1,25 @@
 module ShinyJsonLogic
   module Numericals
     module Numerify
-      def numerified
-        @numerified ||=
-          rules.map do |rule|
-            numerify(rule)
-          end
-      end
-
       private
 
       def numerify(value)
         return value.to_f if value.is_a?(Numeric)
         return 0.0 if value == ""
-        return value.to_f if value.is_a?(String) && value.match?(/\A[+-]?\d*.?\d+\z/)
+        return value.to_f if value.is_a?(String) && numeric_string?(value)
         return 0 if value == false
         return 1 if value == true
         return nil if value.nil?
 
         raise TypeError, "Cannot convert #{value.inspect} to a number"
       end
+
+      def numeric_string?(value)
+        Float(value)
+        true
+      rescue ArgumentError
+        false
+      end
     end
   end
-end
+end

data/lib/shiny_json_logic/numericals/with_error_handling.rb

@@ -1,28 +1,33 @@
+require "shiny_json_logic/errors/base"
+
 module ShinyJsonLogic
   module Numericals
     module WithErrorHandling
       def safe_arithmetic(&block)
         result = yield
-        result.tap do |res|
-          handle_invalid_operand if res.to_f.nan? || res == Float::INFINITY || res == -Float::INFINITY
+        if result.to_f.nan? || result == Float::INFINITY || result == -Float::INFINITY
+          return handle_nan
         end
+        result
       rescue TypeError
-        handle_invalid_operand
+        handle_nan
       end
 
-      def handle_invalid_operand
-        self.data["type"] = "NaN"
+      def handle_nan
         error = ShinyJsonLogic::Errors::Base.new(type: "NaN")
-        errors.push error
-        return error.id
+        self.errors << error
+        error.id
       end
 
-      def handle_no_operators
-        error = Errors::Base.new(type: "Invalid Arguments")
+      def handle_invalid_args
+        error = ShinyJsonLogic::Errors::Base.new(type: "Invalid Arguments")
         self.errors << error
-
         error.id
       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

@@ -1,6 +1,6 @@
 require "shiny_json_logic/operations/base"
-require "shiny_json_logic/numericals/numerify"
 require "shiny_json_logic/numericals/with_error_handling"
+require "shiny_json_logic/numericals/numerify"
 
 module ShinyJsonLogic
   module Operations
@@ -11,20 +11,30 @@ module ShinyJsonLogic
       protected
 
       def run
-
         safe_arithmetic do
-          return 0 if numerified.empty?
+          result = 0.0
+          count = 0
+
+          each_operand do |num|
+            count += 1
+            result = result + num
+          end
 
-          numerified.reduce(:+)
+          result
         end
       end
 
       private
 
+      def each_operand
+        Array.wrap_nil(rules).each do |rule|
+          yield numerify(evaluate(rule))
+        end
+      end
+
       def numerify(value)
         val = super
         return 0 if val.nil?
-
         val
       end
     end

data/lib/shiny_json_logic/operations/all.rb

@@ -4,12 +4,14 @@ require "shiny_json_logic/operations/iterable/base"
 module ShinyJsonLogic
   module Operations
     class All < Iterable::Base
+      raise_on_dynamic_args!
+
       private
 
       def on_after(results)
         return false if results.empty?
 
-        results.all? { |res| res == true }
+        results.all? { |res| Truthy.call(res) }
       end
     end
   end

data/lib/shiny_json_logic/operations/and.rb

@@ -1,13 +1,26 @@
 require "shiny_json_logic/operations/base"
 require "shiny_json_logic/truthy"
+require "shiny_json_logic/numericals/with_error_handling"
 
 module ShinyJsonLogic
   module Operations
     class And < Base
+      include Numericals::WithErrorHandling
+      raise_on_dynamic_args!
+
       protected
 
       def run
-        rules.reduce { |a, b| Truthy.call(a) ? b : a }
+        return handle_invalid_args if dynamic_args?
+        return handle_invalid_args unless rules.is_a?(Array)
+        return false if rules.empty?
+
+        result = nil
+        rules.each do |rule|
+          result = evaluate(rule)
+          return result unless Truthy.call(result)
+        end
+        result
       end
     end
   end

data/lib/shiny_json_logic/operations/base.rb

@@ -5,7 +5,9 @@ module ShinyJsonLogic
     class Base
       def initialize(context)
         @context = context
-        @rules, @data, @errors = @context.values_at("rules", "data", "errors")
+        @rules, @errors, @scope_stack = @context.values_at("rules", "errors", "scope_stack")
+        @dynamic_args = operation?(@rules)
+        @rules = pre_process(@rules)
       end
 
       def call
@@ -14,15 +16,54 @@ module ShinyJsonLogic
 
       protected
 
-      attr_reader :context
-      attr_accessor :rules, :data, :errors
+      attr_reader :context, :scope_stack
+      attr_accessor :rules, :errors
+
+      # Access current data through scope_stack
+      def data
+        scope_stack.current
+      end
 
       def run
         raise NotImplementedError
       end
 
       def deliver(result = nil)
-        {"result" => result, "data" => self.data, "errors" => self.errors}
+        {"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
+      end
+
+      def dynamic_args?
+        @dynamic_args && self.class.raise_on_dynamic_args?
+      end
+
+      def self.raise_on_dynamic_args!
+        @raise_on_dynamic_args = true
+      end
+
+      def self.raise_on_dynamic_args?
+        @raise_on_dynamic_args
+      end
+
+      private
+
+      def pre_process(rules)
+        if operation?(rules)
+          evaluate(rules)
+        else
+          rules
+        end
+      end
+
+      def operation?(value)
+        return false unless value.is_a?(Hash) && !value.empty?
+        OperatorSolver.new.operation?(value)
       end
     end
   end

data/lib/shiny_json_logic/operations/coalesce.rb

@@ -6,7 +6,11 @@ module ShinyJsonLogic
       protected
 
       def run
-        rules.compact.first
+        rules.each do |rule|
+          result = evaluate(rule)
+          return result unless result.nil?
+        end
+        nil
       end
     end
   end

data/lib/shiny_json_logic/operations/concatenation.rb

@@ -6,9 +6,12 @@ module ShinyJsonLogic
       protected
 
       def run
-        return rules.map(&:to_s).join if rules.is_a?(Array)
-
-        rules
+        result = []
+        Array.wrap_nil(rules).each do |rule|
+          evaluated = evaluate(rule)
+          Array.wrap_nil(evaluated).each { |v| result << v.to_s }
+        end
+        result.join
       end
     end
   end

data/lib/shiny_json_logic/operations/different.rb

@@ -1,12 +1,58 @@
 require "shiny_json_logic/operations/base"
-require "shiny_json_logic/operations/equal"
+require "shiny_json_logic/numericals/with_error_handling"
+require "shiny_json_logic/numericals/numerify"
 
 module ShinyJsonLogic
   module Operations
     class Different < Base
-      def call
-        ctx = Operations::Equal.new(context).call
-        {"result" => !ctx["result"], "data" => ctx["data"], "errors" => ctx["errors"]}
+      include Numericals::WithErrorHandling
+      include Numericals::Numerify
+      raise_on_dynamic_args!
+
+      protected
+
+      def run
+        return handle_invalid_args if dynamic_args?
+        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 if result == 0  # Si son iguales, != es false
+          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
       end
     end
   end

data/lib/shiny_json_logic/operations/division.rb

@@ -11,23 +11,36 @@ module ShinyJsonLogic
       protected
 
       def run
-        return handle_no_operators if rules.empty?
-        return handle_nil_operands if rules.any?(&:nil?)
+        operands = Array.wrap_nil(rules)
+        return handle_invalid_args if operands.empty?
+
+        result = nil
+        count = 0
+
+        begin
+          each_operand(operands) do |num|
+            return handle_nan if num.nil?
+            count += 1
+            result = result.nil? ? num : result / num
+          end
+        rescue TypeError
+          return handle_nan
+        end
 
-        safe_arithmetic do
-          self.rules = [1, *rules] if rules.size < 2
+        return handle_invalid_args if count == 0
 
-          numerified.reduce(:/)
-        end
+        final_result = count == 1 ? 1.0 / result : result
+
+        safe_arithmetic { final_result }
       end
 
       private
 
-      def handle_nil_operands
-        error = Errors::Base.new(type: "NaN")
-        self.errors << error
-
-        error.id
+      def each_operand(operands)
+        operands.each do |rule|
+          evaluated = evaluate(rule)
+          yield numerify(evaluated)
+        end
       end
     end
   end

data/lib/shiny_json_logic/operations/double_not.rb

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

data/lib/shiny_json_logic/operations/equal.rb

@@ -1,12 +1,57 @@
 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 Equal < Base
+      include Numericals::WithErrorHandling
+      include Numericals::Numerify
+      raise_on_dynamic_args!
+
       protected
 
       def run
-        rules.map(&:to_s).all? { |v| v == rules[0].to_s }
+        return handle_invalid_args if dynamic_args?
+        operands = Array.wrap_nil(rules)
+        return handle_invalid_args if operands.length < 2
+
+        first = evaluate(operands[0])
+        operands[1..].each do |rule|
+          curr = evaluate(rule)
+          result = compare(first, curr)
+          return handle_nan if result == :nan
+          return false unless result == 0
+        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