shiny_json_logic 0.2.16 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a4ebb694ae1ef43b04f2ef7a750bc102f202cc2e9efa6e0f43361bc66b82d4f
-  data.tar.gz: e57b52493d8d60506c2ceb5c30bace49790bbd6fa5eb2e800f31fb4aae94bbd6
+  metadata.gz: df6cbb1873a1d4237a634ab972f9da4f2e1b56012f0e9353e34c723746f75655
+  data.tar.gz: b62ce7480cdbab13df690836b3c837b96b360d08fb6cd0c86ee8e743222234bc
 SHA512:
-  metadata.gz: 2b336cd498e0286fe1a2f953fc43a8319b83b3792f4471ff8f78eed0dd7cb9174ade63f7fba91b7accca6eccedffb785fb413eae82de9d7f67611d5a5ea64959
-  data.tar.gz: 3f76cf1ac0abea0a1e04a2b6ed2c1b468a028018a471afb20e88b4031555bdadaf0f917f179a84a0c258f4404bf9d61e7ad36a9e07c660a5ebd0177f7236e324
+  metadata.gz: cb846733714d95672c98d615c1474582e5516d13e02becbe13a9839d7571d7f2792235595777464b53c5e4173ea8af49d5d721d09283bfa72ade52f231bb74f7
+  data.tar.gz: 121d271417ace9b145dfc92861e7857ff8c22eb859a7a8d9f2d8ff6b37708a1ee3c55a22f60cf925c1826c41622012848a2a54dd3f4afc9b8084b4ae6424a8e1

data/CHANGELOG.md

@@ -1,6 +1,10 @@
 # Changelog
 
 All notable changes to this project will be documented in this file.
+## [0.3.0] - 2026-02-21
+### Changed
+- Refactors internal architecture to improve performance by removing instantiation of operations.
+
 ## [0.2.16] - 2026-02-21
 ### Changed
 - Removed simple delegator to check indifferent access in favour of key transformation . This improves performance and reduces memory usage.

data/Gemfile.lock

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

data/README.md

@@ -18,13 +18,12 @@ This gem focuses on predictable behavior, strict spec alignment, high compatibil
 - 🕰️ **Ruby 2.7+ compatible**, one of the lowest minimum versions supported in the Ruby ecosystem.
 - 🔧 **Actively maintained** and continuously improved.
 - 📊 **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)
+Try it out in the sandbox at [jsonlogicruby.com](https://jsonlogicruby.com/playground) or run the official test suite with `bin/test.sh` to see the compatibility for yourself.
 
 ---
 
@@ -158,9 +157,6 @@ Currently implemented operators include:
 ### Evaluation
 `preserve`✨
 
-📌 **Note:**  
-`val`, `exists`, `??`, `try`, `throw` and `preserve` are **only supported by ShinyJsonLogic** among Ruby implementations.
-
 See the [spec](https://jsonlogicruby.com/docs) for the full list of operators and their behavior.
 
 ---

data/lib/shiny_json_logic/comparisons/comparable.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 require "shiny_json_logic/numericals/numerify"
+require "shiny_json_logic/errors/not_a_number"
+require "shiny_json_logic/errors/invalid_arguments"
 
 module ShinyJsonLogic
   module Comparisons
     module Comparable
-      include Numericals::Numerify
-
-      private
+      module_function
 
       def compare(a, b)
         return :nan if a.is_a?(Array) || a.is_a?(Hash) || b.is_a?(Array) || b.is_a?(Hash)
@@ -28,9 +28,32 @@ module ShinyJsonLogic
         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)
+        return value.to_f if value.is_a?(String) && Numericals::Numerify.numeric_string?(value)
         nil
       end
+
+      # Normalize numeric types for strict equality comparisons (=== semantics).
+      def cast(value)
+        value.is_a?(Numeric) ? value.to_f : value
+      end
+
+      # Shared loop for all chain-comparison operators.
+      # Yields the compare result for each consecutive pair; block returns true to continue, false to short-circuit.
+      # Returns true if all pairs pass, false otherwise. Raises on :nan or invalid args.
+      def compare_chain(rules, scope_stack)
+        operands = Utils::Array.wrap_nil(rules)
+        raise Errors::InvalidArguments if operands.length < 2
+
+        prev = Engine.call(operands[0], scope_stack)
+        operands[1..].each do |rule|
+          curr = Engine.call(rule, scope_stack)
+          result = compare(prev, curr)
+          raise Errors::NotANumber if result == :nan
+          return false unless yield(result)
+          prev = curr
+        end
+        true
+      end
     end
   end
 end

data/lib/shiny_json_logic/engine.rb

@@ -15,7 +15,7 @@ module ShinyJsonLogic
         
         return rule unless OPERATIONS.key?(operation_key)
 
-        OPERATIONS.fetch(operation_key).new(args, scope_stack).call
+        OPERATIONS.fetch(operation_key).call(args, scope_stack)
       elsif rule.is_a?(Array)
         rule.map { |val| call(val, scope_stack) }
       else

data/lib/shiny_json_logic/numericals/min_max_collection.rb

@@ -5,29 +5,24 @@ require "shiny_json_logic/errors/invalid_arguments"
 module ShinyJsonLogic
   module Numericals
     module MinMaxCollection
-      private
+      module_function
 
-      def collect_numeric_values
-        values = collect_values
+      def collect_numeric_values(rules, scope_stack)
+        values = collect_values(rules, scope_stack)
         raise Errors::InvalidArguments if values.empty?
         raise Errors::InvalidArguments unless values.all? { |v| v.is_a?(Numeric) }
         values
       end
 
-      def collect_values
-        # Logic chaining: if rules is a single operation, expand the result
-        # e.g., {"max": {"val": "data"}} where data is [1,2,3] -> max of 1,2,3
-        if operation?(rules)
-          evaluated = evaluate(rules)
-          return wrap_nil(evaluated)
+      def collect_values(rules, scope_stack)
+        if Operations::Base.op?(rules)
+          evaluated = Engine.call(rules, scope_stack)
+          return Utils::Array.wrap_nil(evaluated)
         end
 
-        # Otherwise, rules is an array of arguments - evaluate each without expanding
-        # e.g., {"max": [1, 2, 3]} or {"max": [1, {"val": "x"}]}
-        # Note: {"max": [{"val": "data"}]} where data is [1,2,3] -> invalid (array is one element)
         result = []
-        wrap_nil(rules).each do |rule|
-          result << evaluate(rule)
+        Utils::Array.wrap_nil(rules).each do |rule|
+          result << Engine.call(rule, scope_stack)
         end
         result
       end

data/lib/shiny_json_logic/numericals/numerify.rb

@@ -3,7 +3,11 @@
 module ShinyJsonLogic
   module Numericals
     module Numerify
-      private
+      # Regex to match valid numeric strings (integers, floats, scientific notation)
+      # Examples: "123", "-45.67", "+3.14", "1e10", "2.5E-3", ".5", "-.5"
+      NUMERIC_REGEX = /\A[+-]?(?:\d+\.?\d*|\d*\.?\d+)(?:[eE][+-]?\d+)?\z/
+
+      module_function
 
       def numerify(value)
         return value.to_f if value.is_a?(Numeric)
@@ -16,10 +20,6 @@ module ShinyJsonLogic
         raise TypeError, "Cannot convert #{value.inspect} to a number"
       end
 
-      # Regex to match valid numeric strings (integers, floats, scientific notation)
-      # Examples: "123", "-45.67", "+3.14", "1e10", "2.5E-3", ".5", "-.5"
-      NUMERIC_REGEX = /\A[+-]?(?:\d+\.?\d*|\d*\.?\d+)(?:[eE][+-]?\d+)?\z/
-
       def numeric_string?(value)
         NUMERIC_REGEX.match?(value)
       end

data/lib/shiny_json_logic/numericals/with_error_handling.rb

@@ -7,6 +7,8 @@ require "shiny_json_logic/errors/invalid_arguments"
 module ShinyJsonLogic
   module Numericals
     module WithErrorHandling
+      module_function
+
       def safe_arithmetic(&block)
         result = yield
         if result.to_f.nan? || result == Float::INFINITY || result == -Float::INFINITY

data/lib/shiny_json_logic/operations/addition.rb

@@ -7,36 +7,18 @@ require "shiny_json_logic/numericals/numerify"
 module ShinyJsonLogic
   module Operations
     class Addition < Base
-      include Numericals::WithErrorHandling
-      include Numericals::Numerify
+      extend Numericals::WithErrorHandling
 
-      def call
+      def self.execute(rules, scope_stack)
         safe_arithmetic do
           result = 0.0
-          count = 0
-
-          each_operand do |num|
-            count += 1
-            result = result + num
+          Utils::Array.wrap_nil(rules).each do |rule|
+            val = Numericals::Numerify.numerify(evaluate(rule, scope_stack))
+            result += val.nil? ? 0 : val
           end
-
           result
         end
       end
-
-      private
-
-      def each_operand
-        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
   end
 end

data/lib/shiny_json_logic/operations/all.rb

@@ -8,9 +8,7 @@ module ShinyJsonLogic
     class All < Iterable::Base
       raise_on_dynamic_args!
 
-      private
-
-      def on_after(results)
+      def self.on_after(results, _scope_stack)
         return false if results.empty?
 
         results.all? { |res| Truthy.call(res) }

data/lib/shiny_json_logic/operations/and.rb

@@ -7,17 +7,16 @@ require "shiny_json_logic/numericals/with_error_handling"
 module ShinyJsonLogic
   module Operations
     class And < Base
-      include Numericals::WithErrorHandling
+      extend Numericals::WithErrorHandling
       raise_on_dynamic_args!
 
-      def call
-        return handle_invalid_args if dynamic_args?
+      def self.execute(rules, scope_stack)
         return handle_invalid_args unless rules.is_a?(Array)
         return false if rules.empty?
 
         result = nil
         rules.each do |rule|
-          result = evaluate(rule)
+          result = evaluate(rule, scope_stack)
           return result unless Truthy.call(result)
         end
         result

data/lib/shiny_json_logic/operations/base.rb

@@ -6,34 +6,21 @@ require "shiny_json_logic/utils/array"
 module ShinyJsonLogic
   module Operations
     class Base
-      include Utils::Array
+      extend Utils::Array
 
-      def initialize(rules, scope_stack)
-        @scope_stack = scope_stack
-        @dynamic_args = operation?(rules)
-        @rules = pre_process(rules)
+      def self.call(rules, scope_stack)
+        execute(resolve_rules(rules, scope_stack), scope_stack)
       end
 
-      def call
-        raise NotImplementedError
-      end
-
-      protected
-
-      attr_reader :scope_stack
-      attr_accessor :rules
-
-      # Access current data through scope_stack
-      def data
-        scope_stack.current
-      end
-
-      def evaluate(rule)
-        Engine.call(rule, scope_stack)
+      def self.resolve_rules(rules, scope_stack)
+        dynamic = op?(rules)
+        rules = Engine.call(rules, scope_stack) if dynamic
+        raise Errors::InvalidArguments if dynamic && raise_on_dynamic_args?
+        rules
       end
 
-      def dynamic_args?
-        @dynamic_args && self.class.raise_on_dynamic_args?
+      def self.execute(_rules, _scope_stack)
+        raise NotImplementedError
       end
 
       def self.raise_on_dynamic_args!
@@ -44,17 +31,12 @@ module ShinyJsonLogic
         @raise_on_dynamic_args
       end
 
-      private
-
-      def pre_process(rules)
-        return evaluate(rules) if operation?(rules)
-
-        rules
+      def self.evaluate(rule, scope_stack)
+        Engine.call(rule, scope_stack)
       end
 
-      def operation?(value)
+      def self.op?(value)
         return false unless value.is_a?(Hash) && !value.empty?
-
         OperatorSolver.operation?(value)
       end
     end

data/lib/shiny_json_logic/operations/coalesce.rb

@@ -5,9 +5,9 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Coalesce < Base
-      def call
+      def self.execute(rules, scope_stack)
         rules.each do |rule|
-          result = evaluate(rule)
+          result = evaluate(rule, scope_stack)
           return result unless result.nil?
         end
         nil

data/lib/shiny_json_logic/operations/concatenation.rb

@@ -5,11 +5,11 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Concatenation < Base
-      def call
+      def self.execute(rules, scope_stack)
         result = []
-        wrap_nil(rules).each do |rule|
-          evaluated = evaluate(rule)
-          wrap_nil(evaluated).each { |v| result << v.to_s }
+        Utils::Array.wrap_nil(rules).each do |rule|
+          evaluated = evaluate(rule, scope_stack)
+          Utils::Array.wrap_nil(evaluated).each { |v| result << v.to_s }
         end
         result.join
       end

data/lib/shiny_json_logic/operations/different.rb

@@ -1,30 +1,15 @@
 # frozen_string_literal: true
 
 require "shiny_json_logic/operations/base"
-require "shiny_json_logic/numericals/with_error_handling"
 require "shiny_json_logic/comparisons/comparable"
 
 module ShinyJsonLogic
   module Operations
     class Different < Base
-      include Numericals::WithErrorHandling
-      include Comparisons::Comparable
       raise_on_dynamic_args!
 
-      def call
-        return handle_invalid_args if dynamic_args?
-        operands = 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
-          prev = curr
-        end
-        true
+      def self.execute(rules, scope_stack)
+        Comparisons::Comparable.compare_chain(rules, scope_stack) { |r| r != 0 }
       end
     end
   end

data/lib/shiny_json_logic/operations/division.rb

@@ -7,18 +7,19 @@ require "shiny_json_logic/numericals/numerify"
 module ShinyJsonLogic
   module Operations
     class Division < Base
-      include Numericals::WithErrorHandling
-      include Numericals::Numerify
+      extend Numericals::WithErrorHandling
 
-      def call
-        operands = wrap_nil(rules)
+      def self.execute(rules, scope_stack)
+        operands = Utils::Array.wrap_nil(rules)
         return handle_invalid_args if operands.empty?
 
         result = nil
         count = 0
 
         begin
-          each_operand(operands) do |num|
+          operands.each do |rule|
+            evaluated = evaluate(rule, scope_stack)
+            num = Numericals::Numerify.numerify(evaluated)
             return handle_nan if num.nil?
             count += 1
             result = result.nil? ? num : result / num
@@ -33,15 +34,6 @@ module ShinyJsonLogic
 
         safe_arithmetic { final_result }
       end
-
-      private
-
-      def each_operand(operands)
-        operands.each do |rule|
-          evaluated = evaluate(rule)
-          yield numerify(evaluated)
-        end
-      end
     end
   end
 end

data/lib/shiny_json_logic/operations/double_not.rb

@@ -6,9 +6,9 @@ require "shiny_json_logic/truthy"
 module ShinyJsonLogic
   module Operations
     class DoubleNot < Base
-      def call
-        value = wrap_nil(rules).first
-        !!Truthy.call(evaluate(value))
+      def self.execute(rules, scope_stack)
+        value = Utils::Array.wrap_nil(rules).first
+        !!Truthy.call(evaluate(value, scope_stack))
       end
     end
   end

data/lib/shiny_json_logic/operations/equal.rb

@@ -1,29 +1,15 @@
 # frozen_string_literal: true
 
 require "shiny_json_logic/operations/base"
-require "shiny_json_logic/numericals/with_error_handling"
 require "shiny_json_logic/comparisons/comparable"
 
 module ShinyJsonLogic
   module Operations
     class Equal < Base
-      include Numericals::WithErrorHandling
-      include Comparisons::Comparable
       raise_on_dynamic_args!
 
-      def call
-        return handle_invalid_args if dynamic_args?
-        operands = 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
+      def self.execute(rules, scope_stack)
+        Comparisons::Comparable.compare_chain(rules, scope_stack) { |r| r == 0 }
       end
     end
   end

data/lib/shiny_json_logic/operations/exists.rb

@@ -5,11 +5,11 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Exists < Base
-      def call
-        current = data
+      def self.execute(rules, scope_stack)
+        current = scope_stack.current
 
-        wrap_nil(rules).each do |rule|
-          segment = evaluate(rule)
+        Utils::Array.wrap_nil(rules).each do |rule|
+          segment = evaluate(rule, scope_stack)
           return false unless current.key?(segment)
           current = current[segment]
         end

data/lib/shiny_json_logic/operations/filter.rb

@@ -9,13 +9,11 @@ module ShinyJsonLogic
       raise_on_nil_filter!
       raise_on_dynamic_args!
 
-      private
-
-      def on_each(item)
+      def self.on_each(item, filter, scope_stack)
         Truthy.call(Engine.call(filter, scope_stack)) ? item : nil
       end
 
-      def on_after(results)
+      def self.on_after(results, _scope_stack)
         results.compact
       end
     end

data/lib/shiny_json_logic/operations/greater.rb

@@ -1,30 +1,15 @@
 # frozen_string_literal: true
 
 require "shiny_json_logic/operations/base"
-require "shiny_json_logic/numericals/with_error_handling"
 require "shiny_json_logic/comparisons/comparable"
 
 module ShinyJsonLogic
   module Operations
     class Greater < Base
-      include Numericals::WithErrorHandling
-      include Comparisons::Comparable
       raise_on_dynamic_args!
 
-      def call
-        return handle_invalid_args if dynamic_args?
-        operands = wrap_nil(rules)
-        return handle_invalid_args if operands.length < 2
-
-        prev = evaluate(operands[0])
-        operands[1..].each do |rule|
-          curr = evaluate(rule)
-          result = compare(prev, curr)
-          return handle_nan if result == :nan
-          return false unless result == 1
-          prev = curr
-        end
-        true
+      def self.execute(rules, scope_stack)
+        Comparisons::Comparable.compare_chain(rules, scope_stack) { |r| r == 1 }
       end
     end
   end

data/lib/shiny_json_logic/operations/greater_equal.rb

@@ -1,30 +1,15 @@
 # frozen_string_literal: true
 
 require "shiny_json_logic/operations/base"
-require "shiny_json_logic/numericals/with_error_handling"
 require "shiny_json_logic/comparisons/comparable"
 
 module ShinyJsonLogic
   module Operations
     class GreaterEqual < Base
-      include Numericals::WithErrorHandling
-      include Comparisons::Comparable
       raise_on_dynamic_args!
 
-      def call
-        return handle_invalid_args if dynamic_args?
-        operands = wrap_nil(rules)
-        return handle_invalid_args if operands.length < 2
-
-        prev = evaluate(operands[0])
-        operands[1..].each do |rule|
-          curr = evaluate(rule)
-          result = compare(prev, curr)
-          return handle_nan if result == :nan
-          return false unless result >= 0
-          prev = curr
-        end
-        true
+      def self.execute(rules, scope_stack)
+        Comparisons::Comparable.compare_chain(rules, scope_stack) { |r| r >= 0 }
       end
     end
   end

data/lib/shiny_json_logic/operations/if.rb

@@ -7,34 +7,23 @@ require "shiny_json_logic/numericals/with_error_handling"
 module ShinyJsonLogic
   module Operations
     class If < Base
-      include Numericals::WithErrorHandling
+      extend Numericals::WithErrorHandling
 
-      # Skip pre_process - spec requires static array, dynamic args should error
-      def initialize(rules, scope_stack)
-        @rules = rules
-        @scope_stack = scope_stack
-      end
-
-      def call
+      def self.call(rules, scope_stack)
+        # Skip pre_process - spec requires static array, dynamic args should error
         return handle_invalid_args unless rules.is_a?(Array)
 
         rules.each_slice(2) do |condition_rule, value_rule|
-          condition_result = evaluate(condition_rule)
+          condition_result = Engine.call(condition_rule, scope_stack)
           return condition_result if value_rule.nil?
 
           next unless Truthy.call(condition_result)
 
-          return evaluate(value_rule)
+          return Engine.call(value_rule, scope_stack)
         end
 
         nil
       end
-
-      private
-
-      def evaluate(rule)
-        Engine.call(rule, scope_stack)
-      end
     end
   end
 end

data/lib/shiny_json_logic/operations/inclusion.rb

@@ -5,9 +5,9 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Inclusion < Base
-      def call
-        needle = evaluate(rules.first)
-        haystack = evaluate(rules.last)
+      def self.execute(rules, scope_stack)
+        needle = evaluate(rules.first, scope_stack)
+        haystack = evaluate(rules.last, scope_stack)
         haystack.include?(needle)
       end
     end