shiny_json_logic 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c094c662a616d343c0d045d0c8da1173fb1f982c19b709ffc1e9c8550813092
-  data.tar.gz: 872f71f3d52d7dc6d16a98e2fbf97cd50c07d9d901f7a2ac29ec831a86aa2621
+  metadata.gz: afe72b83c4cd5884c3718de47470d643c06448547400213242c05149115be095
+  data.tar.gz: e45b27746d1e8227a3760ee9c0a55d07dccd9503485a2934f2049ec38c9306b0
 SHA512:
-  metadata.gz: d28d16b67aaa1aa1435e2babfc2bf4b600c059ee896d863d85d1ba5460397a6eab0c4825575046ca72d0b1f804176710817bedc47d576eb84859e58af6996853
-  data.tar.gz: '099460668bdd8641e3f37d2ece887eca7100ccf3d7e5ade02c57317c2676a163dcf4ed2aedb417037f6779d133051ca07a7b785e98b3f5661b83259edfb2b0a3'
+  metadata.gz: d6798164621aea875879d1dbc9c0f4b548036e1a1bf18ba7bdc463740a55b92ccfca12bd3c6cd3315af0b1e94c5e3ad402014de80d510b2a4a4e6cb0f29f0d9a
+  data.tar.gz: d9a8eb8c365817e8e4a8a1cf109711a6dee51068d1275b04aa31e43448c43674eeaba7bae570f65615a8ef5b42fd1572b87eedd7075ff6bce705d814cfaa34ed

data/AGENTS.md

@@ -0,0 +1,131 @@
+# Estado del Refactor: Eliminar Syntactic Sugar de Array.wrap_nil en Engine
+
+## Instrucciones para el Agente
+
+**IMPORTANTE:** Antes de modificar cualquier fichero:
+1. Explicar qué cambio se va a hacer y por qué
+2. Preguntar al usuario si procedemos o no
+3. Solo modificar tras confirmación explícita
+
+## Contexto
+
+Estamos refactorizando la implementación de JSONLogic para Ruby para eliminar el "syntactic sugar" que convertía automáticamente todos los argumentos a arrays en `engine.rb:20`.
+
+### Cambio Principal
+
+**Antes:**
+```ruby
+operation, raw_args = rule.to_a.first
+args = Array.wrap_nil(raw_args)
+solve(operation, args, data)
+```
+
+**Después:**
+```ruby
+operation, raw_args = rule.to_a.first
+solve(operation, raw_args, data)
+```
+
+## Filosofía
+
+En JSONLogic:
+- Las operaciones deben ser O(n), nunca O(n²)
+- Si un argumento es un hash con operador, se evalúa en el preprocesado de `base.rb`
+- Si un argumento es un array, ES un array (no se aplana)
+- Si un argumento es un valor unitario (número, string, boolean, nil, hash vacío), se maneja como tal
+
+## Progreso
+
+### Operaciones Arregladas
+- `!` (not.rb) - Usa `rules.is_a?(Array) ? rules.first : rules`
+- `+` (addition.rb) - Usa `Array.wrap_nil(rules).each`, sin aplanar resultado de evaluate
+- `val` (val.rb) - Usa `Array.wrap_nil(rules)`
+- `var` (var.rb) - Usa `Array.wrap_nil(rules)`
+- `max` (max.rb) - Usa `Array.wrap_nil(rules).each`
+- `cat` (concatenation.rb) - Usa `Array.wrap_nil(rules).each`
+- `merge` (merge.rb) - Usa `Array.wrap_nil(rules).map`
+- `exists` (exists.rb) - Usa `Array.wrap_nil(rules).each` (también eliminado O(n²))
+- `missing` (missing.rb) - Usa `Array.wrap_nil(rules)` y quitado chequeo innecesario
+- `-` (subtraction.rb) - Usa `Array.wrap_nil(rules)` para manejar argumentos directos
+- `/` (division.rb) - Usa `Array.wrap_nil(rules)` para manejar argumentos directos
+- `%` (modulo.rb) - Usa `Array.wrap_nil(rules)` para manejar argumentos directos
+- `*` (product.rb) - Usa `Array.wrap_nil(rules)` para manejar argumentos directos
+- `>` (greater.rb) - Reescrito con comparación de tipos, NaN para arrays/objetos
+- `>=` (greater_equal.rb) - Reescrito con comparación de tipos
+- `<` (smaller.rb) - Reescrito con comparación de tipos
+- `<=` (smaller_equal.rb) - Reescrito con comparación de tipos
+- `==` (equal.rb) - Reescrito con coerción de tipos y manejo de NaN
+- `!=` (different.rb) - Reescrito con comparación consecutiva de pares
+- `===` (strict_equal.rb) - Añadida validación de argumentos mínimos
+- `!==` (strict_different.rb) - Reescrito con comparación consecutiva de pares
+
+### Módulo WithErrorHandling
+Se centralizó el manejo de errores en `lib/shiny_json_logic/numericals/with_error_handling.rb`:
+- `handle_nan` - Retorna error de tipo "NaN"
+- `handle_invalid_args` - Retorna error de tipo "Invalid Arguments"
+- Aliases para compatibilidad: `handle_invalid_operand`, `handle_no_operators`
+
+### Preprocesado en base.rb
+Se añadió preprocesado que evalúa hashes con operadores antes de pasarlos a la operación:
+```ruby
+def preprocess(rules)
+  if operation?(rules)
+    evaluate(rules)
+  else
+    rules
+  end
+end
+```
+
+## Estado Actual
+
+- **Tests internos (spec/):** 315/315 pasando (100%)
+- **Compatibilidad estándar (bin/test.sh):** 1041/1126 (92.5%)
+- **Objetivo:** 84% mínimo ✅ ALCANZADO
+
+## Operaciones Pendientes de Arreglar
+
+Los fallos restantes (85) están principalmente en:
+
+1. **Operadores con argumentos dinámicos** - Casos donde se pasa un array dinámico via `preserve`
+2. **`all`, `some`, `none`** - Casos "Missing array returns error"
+3. **`and`, `or`, `if`** - Casos edge con argumentos no-array
+
+## Patrón de Arreglo
+
+Para cada operación que falla, el patrón general es:
+
+1. Identificar dónde asume que `rules` es un array (ej: `rules.each`, `rules.first`, `rules[0]`)
+2. Envolver con `Array.wrap_nil(rules)` para manejar valores unitarios
+3. Incluir `Numericals::WithErrorHandling` para usar `handle_nan` y `handle_invalid_args`
+4. Verificar que no se esté haciendo aplanado innecesario (mantener O(n))
+
+## Cómo Continuar
+
+1. Correr `bundle exec rspec` para verificar tests internos
+2. Correr `bin/test.sh` para ver compatibilidad estándar
+3. Identificar operación con fallos
+4. Ver casos de test que fallan para esa operación
+5. Modificar la operación siguiendo el patrón
+6. Repetir
+
+## Comandos Útiles
+
+```bash
+# Tests internos
+bundle exec rspec
+
+# Tests de compatibilidad estándar
+bin/test.sh
+
+# Ver fallos por operación
+bin/test.sh 2>&1 | grep -B1 "FAILED" | grep "example" | head -50
+
+# Probar operación específica
+bundle exec ruby -e "
+require 'bundler/setup'
+require 'shiny_json_logic'
+result = ShinyJsonLogic.apply({'operador' => args}, data)
+puts result.inspect
+"
+```

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to this project will be documented in this file.
 
+## [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.7)
 
 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": "92.5% (1041/1126)",
+  "color": "yellow"
 }

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

@@ -17,19 +17,7 @@ module ShinyJsonLogic
         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
+        solve(operation, raw_args, data)
       elsif rule.is_a?(Array)
         rule.map { |val| call(val, data) }
       else

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

@@ -9,7 +9,7 @@ module ShinyJsonLogic
       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

@@ -7,7 +7,12 @@ module ShinyJsonLogic
       protected
 
       def run
-        rules.reduce { |a, b| Truthy.call(a) ? b : a }
+        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

@@ -6,6 +6,7 @@ module ShinyJsonLogic
       def initialize(context)
         @context = context
         @rules, @data, @errors = @context.values_at("rules", "data", "errors")
+        @rules = preprocess(@rules)
       end
 
       def call
@@ -24,6 +25,32 @@ module ShinyJsonLogic
       def deliver(result = nil)
         {"result" => result, "data" => self.data, "errors" => self.errors}
       end
+
+      # Evalúa un argumento raw usando el Engine
+      def evaluate(rule)
+        engine = Engine.new(rule, data)
+        result = engine.call
+        self.errors = [*errors, *engine.errors].uniq
+        result
+      end
+
+      private
+
+      # Pre-procesa las rules:
+      # - Si es un hash con operador, lo evalúa inmediatamente
+      # - Si es array o valor unitario, lo deja como está
+      def preprocess(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
 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,56 @@
 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
+
+      protected
+
+      def run
+        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,7 @@ module ShinyJsonLogic
       protected
 
       def run
-        !!Truthy.call(rules.first)
+        !!Truthy.call(evaluate(rules.first))
       end
     end
   end

data/lib/shiny_json_logic/operations/equal.rb

@@ -1,12 +1,55 @@
 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
+
       protected
 
       def run
-        rules.map(&:to_s).all? { |v| v == rules[0].to_s }
+        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