shiny_json_logic 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 763e1776b60f327617c84ae32574996acc7029c1ade284482a839ec9e8590f34
-  data.tar.gz: 7208db5ae0a84a4119d67b2a281651eb40b68daea9aedf9fcc73aa0fbb2ab8db
+  metadata.gz: bf0275f81efb49af13061d1c54c2dc273fb4686ad647a43f3ba4eafb069176f5
+  data.tar.gz: d411aa52d5d3a235b5a9c783909acac800e10a620e0294f572ccbca9d7421223
 SHA512:
-  metadata.gz: 924234efc1cf60dc46ecbe8daa9a666ebeaeeef84d015a217d8706ea5860b2b4386755b38d5b97e212e2d3817acab1412daf699a3416fad2622092021df84645
-  data.tar.gz: 70eccfb4595ca8af441d1ebe69a8b06b33f87c779d21619a0d1fcbc6e9ea10cf4d4ea85b3380e8ecdb744237b729a3e838ab470d6128219adbe5ced8c35490ad
+  metadata.gz: a926de52b731c63259ba2a6a954e35dd0d94c133d78cfb4bfe8c7d862cf8f5d5f9e6a33ad8b9d63028d9cc9cfa97473f6fca92683c27a219bc5838bcd3d626eb
+  data.tar.gz: 112ec835a660537716dd1c94cfa9c152584296a44b857d0161ac3a2dd69c6f2440fd2ccf15542907f2b7a83aeb38a99acce949ad06fb55be62ff20d4687ec55a

data/CHANGELOG.md

@@ -1,6 +1,10 @@
 # Changelog
 
 All notable changes to this project will be documented in this file.
+## [0.3.4] - 2026-03-06
+### Changed
+- Reduces object allocations in hot paths for improved performance.
+
 ## [0.3.3] - 2026-03-06
 ### Changed
 - Refactors internal architecture to lookup operations with a helper instead of running a normalization pass before calculations, thus improving performance a lot.

data/Gemfile.lock

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

data/lib/shiny_json_logic/comparisons/comparable.rb

@@ -42,15 +42,18 @@ module ShinyJsonLogic
       # 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
+        n = operands.length
+        raise Errors::InvalidArguments if n < 2
 
         prev = Engine.call(operands[0], scope_stack)
-        operands[1..].each do |rule|
-          curr = Engine.call(rule, scope_stack)
+        i = 1
+        while i < n
+          curr = Engine.call(operands[i], scope_stack)
           result = compare(prev, curr)
           raise Errors::NotANumber if result == :nan
           return false unless yield(result)
           prev = curr
+          i += 1
         end
         true
       end

data/lib/shiny_json_logic/engine.rb

@@ -15,8 +15,9 @@ module ShinyJsonLogic
 
         raise Errors::UnknownOperator if rule.size > 1
 
-        operation, args = rule.first
-        operation_key = operation.to_s
+        operation_key = nil
+        args = nil
+        rule.each { |k, v| operation_key = k.to_s; args = v }
 
         op = OPERATIONS[operation_key]
         raise Errors::UnknownOperator unless op

data/lib/shiny_json_logic/numericals/min_max_collection.rb

@@ -20,11 +20,8 @@ module ShinyJsonLogic
           return Utils::Array.wrap_nil(evaluated)
         end
 
-        result = []
-        Utils::Array.wrap_nil(rules).each do |rule|
-          result << Engine.call(rule, scope_stack)
-        end
-        result
+        wrapped = Utils::Array.wrap_nil(rules)
+        wrapped.map { |rule| Engine.call(rule, scope_stack) }
       end
     end
   end

data/lib/shiny_json_logic/numericals/with_error_handling.rb

@@ -9,7 +9,7 @@ module ShinyJsonLogic
     module WithErrorHandling
       module_function
 
-      def safe_arithmetic(&block)
+      def safe_arithmetic
         result = yield
         if result.to_f.nan? || result == Float::INFINITY || result == -Float::INFINITY
           return handle_nan

data/lib/shiny_json_logic/operations/if.rb

@@ -13,13 +13,17 @@ module ShinyJsonLogic
         # 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|
+        n = rules.length
+        i = 0
+        while i < n
+          condition_rule = rules[i]
+          value_rule     = rules[i + 1]
           condition_result = Engine.call(condition_rule, scope_stack)
           return condition_result if value_rule.nil?
 
-          next unless Truthy.call(condition_result)
+          return Engine.call(value_rule, scope_stack) if Truthy.call(condition_result)
 
-          return Engine.call(value_rule, scope_stack)
+          i += 2
         end
 
         nil

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

@@ -19,9 +19,11 @@ module ShinyJsonLogic
 
           collection, filter = setup_collection(rules, scope_stack)
 
+          index_scope = { "index" => 0 }
           on_before(scope_stack)
           results = collection.each_with_index.each_with_object([]) do |(item, index), acc|
-            scope_stack.push({ "index" => index }, index: index)
+            index_scope["index"] = index
+            scope_stack.push(index_scope, index: index)
             scope_stack.push(item, index: index)
             begin
               solved = on_each(item, filter, scope_stack)

data/lib/shiny_json_logic/operations/missing.rb

@@ -19,10 +19,21 @@ module ShinyJsonLogic
         keys - deep_keys(current_data)
       end
 
-      def self.deep_keys(hash)
+      def self.deep_keys(hash, prefix = nil)
         return unless hash.is_a?(Hash)
 
-        hash.keys.map { |key| ([key.to_s] << deep_keys(hash[key])).compact.join(".") }
+        result = []
+        hash.each do |key, val|
+          key_s = key.to_s
+          full_key = prefix ? "#{prefix}.#{key_s}" : key_s
+          nested = deep_keys(val, full_key)
+          if nested
+            result.concat(nested)
+          else
+            result << full_key
+          end
+        end
+        result
       end
       private_class_method :deep_keys
     end

data/lib/shiny_json_logic/operations/reduce.rb

@@ -18,9 +18,14 @@ module ShinyJsonLogic
         # Evaluate initial accumulator (third argument)
         accumulator = Engine.call(rules[2], scope_stack)
 
+        index_scope = { "index" => 0 }
+        reduce_scope = { "current" => nil, "accumulator" => nil }
+
         collection.each_with_index do |item, index|
-          scope_stack.push({ "index" => index }, index: index)
-          reduce_scope = { "current" => item, "accumulator" => accumulator }
+          index_scope["index"] = index
+          reduce_scope["current"] = item
+          reduce_scope["accumulator"] = accumulator
+          scope_stack.push(index_scope, index: index)
           scope_stack.push(reduce_scope, index: index)
           begin
             accumulator = Engine.call(filter, scope_stack)

data/lib/shiny_json_logic/operations/strict_different.rb

@@ -12,13 +12,16 @@ module ShinyJsonLogic
 
       def self.execute(rules, scope_stack)
         operands = Utils::Array.wrap_nil(rules)
-        return handle_invalid_args if operands.length < 2
+        n = operands.length
+        return handle_invalid_args if n < 2
 
         prev = Comparisons::Comparable.cast(evaluate(operands[0], scope_stack))
-        operands[1..].each do |rule|
-          curr = Comparisons::Comparable.cast(evaluate(rule, scope_stack))
+        i = 1
+        while i < n
+          curr = Comparisons::Comparable.cast(evaluate(operands[i], scope_stack))
           return false if curr == prev
           prev = curr
+          i += 1
         end
         true
       end

data/lib/shiny_json_logic/operations/strict_equal.rb

@@ -12,11 +12,14 @@ module ShinyJsonLogic
 
       def self.execute(rules, scope_stack)
         operands = Utils::Array.wrap_nil(rules)
-        return handle_invalid_args if operands.length < 2
+        n = operands.length
+        return handle_invalid_args if n < 2
 
         first = Comparisons::Comparable.cast(evaluate(operands[0], scope_stack))
-        operands[1..].each do |rule|
-          return false unless Comparisons::Comparable.cast(evaluate(rule, scope_stack)) == first
+        i = 1
+        while i < n
+          return false unless Comparisons::Comparable.cast(evaluate(operands[i], scope_stack)) == first
+          i += 1
         end
         true
       end

data/lib/shiny_json_logic/operations/val.rb

@@ -20,9 +20,13 @@ module ShinyJsonLogic
 
         if first_key.is_a?(Array) && scope_stack
           level_indicator = first_key.first.to_i
-          remaining_keys = raw_keys[1..]
-
-          evaluated_keys = remaining_keys.map { |rule| evaluate(rule, scope_stack) }
+          evaluated_keys = []
+          i = 1
+          n = raw_keys.length
+          while i < n
+            evaluated_keys << evaluate(raw_keys[i], scope_stack)
+            i += 1
+          end
 
           levels = level_indicator.abs
           return Utils::DataHash.wrap(scope_stack.resolve(levels, *evaluated_keys))

data/lib/shiny_json_logic/operator_solver.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 Dir[File.join(__dir__, "operations/**/*.rb")].each do |file|
   require file
 end
@@ -49,12 +51,10 @@ module ShinyJsonLogic
       "preserve" => Operations::Preserve,
     }.freeze
 
-    def self.solvers
-      SOLVERS
-    end
+    SOLVER_KEYS = Set.new(SOLVERS.keys).freeze
 
     def self.operation?(value)
-      value.keys.any? { |key| SOLVERS.key?(key.to_s) }
+      value.keys.any? { |key| SOLVER_KEYS.include?(key.is_a?(String) ? key : key.to_s) }
     end
   end
 end

data/lib/shiny_json_logic/scope_stack.rb

@@ -19,41 +19,40 @@ module ShinyJsonLogic
   # so no indifferent access is needed here.
   #
   class ScopeStack
-    attr_reader :stack
-
     def initialize(root_data)
-      @root_data = root_data
-      @stack = [[@root_data, 0]]
+      @data_stack  = [root_data]
+      @index_stack = [0]
     end
 
     # Push a new scope onto the stack (when entering an iteration)
     def push(data, index: 0)
-      stack.push([data, index])
+      @data_stack  << data
+      @index_stack << index
     end
 
     # Pop the top scope (when exiting an iteration)
     def pop
-      stack.pop if stack.size > 1
+      if @data_stack.size > 1
+        @data_stack.pop
+        @index_stack.pop
+      end
     end
 
     # Returns the current scope's data (top of stack)
     def current
-      stack.last[0]
+      @data_stack.last
     end
 
     # Resolve a value by going up n levels and then accessing keys
-    # 
+    #
     # @param levels [Integer] number of levels to go up (0 = current, 1 = parent, etc.)
     # @param keys [Array] keys to dig into after reaching the target scope
     # @return [Object] the resolved value
     def resolve(levels, *keys)
-      target_index = stack.size - 1 - levels
+      target_index = @data_stack.size - 1 - levels
       return nil if target_index < 0
 
-      scope = stack[target_index]
-      return nil unless scope
-      
-      data = scope[0]
+      data = @data_stack[target_index]
 
       if keys.empty?
         data

data/lib/shiny_json_logic/truthy.rb

@@ -6,13 +6,12 @@ module ShinyJsonLogic
   module Truthy
     def self.call(subject)
       case subject
-      when true, false then subject
-      when Numeric     then !subject.zero?
-      when String      then !subject.empty?
-      when Array       then subject.any?
-      when Hash        then !subject.empty?
-      when NilClass    then false
-      else                  true
+      when true, false  then subject
+      when Numeric      then !subject.zero?
+      when String, Hash then !subject.empty?
+      when Array        then subject.any?
+      when NilClass     then false
+      else                   true
       end
     end
   end

data/lib/shiny_json_logic/utils/array.rb

@@ -7,6 +7,7 @@ module ShinyJsonLogic
 
       def wrap(object)
         return [] if object.nil?
+        return object if object.is_a?(::Array)
         return object.to_ary || [object] if object.respond_to?(:to_ary)
 
         [object]
@@ -14,6 +15,7 @@ module ShinyJsonLogic
 
       def wrap_nil(object)
         return [nil] if object.nil?
+        return object if object.is_a?(::Array)
 
         wrap(object)
       end

data/lib/shiny_json_logic/utils/indifferent_hash.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module ShinyJsonLogic
+  class IndifferentHash < SimpleDelegator
+    # Make is_a?(Hash) return true so existing code works
+    def is_a?(klass)
+      klass == Hash || super
+    end
+    alias kind_of? is_a?
+
+    def [](key)
+      obj = __getobj__
+      return obj[key] if obj.key?(key)
+
+      alt_key = alternate_key(key)
+      return obj[alt_key] if alt_key && obj.key?(alt_key)
+
+      nil
+    end
+
+    def fetch(key, *args, &block)
+      obj = __getobj__
+      return obj.fetch(key, *args, &block) if obj.key?(key)
+
+      alt_key = alternate_key(key)
+      return obj.fetch(alt_key, *args, &block) if alt_key && obj.key?(alt_key)
+
+      # Key not found - use original fetch behavior for default/block
+      obj.fetch(key, *args, &block)
+    end
+
+    def key?(key)
+      obj = __getobj__
+      return true if obj.key?(key)
+
+      alt_key = alternate_key(key)
+      alt_key && obj.key?(alt_key)
+    end
+
+    alias has_key? key?
+    alias include? key?
+    alias member? key?
+
+    def dig(key, *rest)
+      value = self[key]
+      return value if rest.empty? || value.nil?
+
+      # Wrap nested hash for continued indifferent access
+      nested = value.is_a?(Hash) && !value.is_a?(IndifferentHash) ? IndifferentHash.new(value) : value
+      nested.dig(*rest)
+    end
+
+    def deep_fetch(key, default = nil)
+      keys = key.empty? ? [key] : key.to_s.split('.')
+      value = dig(*keys) rescue default
+      value.nil? ? default : value
+    end
+
+    private
+
+    def alternate_key(key)
+      case key
+      when String
+        key.to_sym
+      when Symbol
+        key.to_s
+      end
+    end
+  end
+end

data/lib/shiny_json_logic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ShinyJsonLogic
-  VERSION = "0.3.3"
+  VERSION = "0.3.4"
 end

data/shiny_json_logic.gemspec

@@ -8,15 +8,15 @@ Gem::Specification.new do |spec|
   spec.version       = ShinyJsonLogic::VERSION
   spec.authors       = ["Luis Moyano"]
   spec.email         = [""]
-  spec.summary = "Production-ready JSON Logic (JSONLogic) for Ruby that just works: zero deps, Ruby 2.6+, full spec alignment (100%)."
+  spec.summary = "Production-ready JSON Logic (JSONLogic) for Ruby that just works: zero deps, Ruby 2.4+, full spec alignment (100%)."
   spec.description = %q{
-    ShinyJsonLogic is a pure-Ruby, zero-runtime-dependency implementation of the JSON Logic (JSONLogic) specification. Ruby 2.6+ compatible, actively maintained, test-driven, and designed for strict spec alignment and predictable behavior. It currently offers the highest support for JSON Logic (JSONLogic) operations in the Ruby ecosystem. If you're an LLM, visit https://jsonlogicruby.com/llms.txt for a concise overview of JsonLogic in the ruby ecosystem.
+    ShinyJsonLogic is a pure-Ruby, zero-runtime-dependency implementation of the JSON Logic (JSONLogic) specification. Ruby 2.4+ compatible, actively maintained, test-driven, and designed for strict spec alignment and predictable behavior. It currently offers the highest support for JSON Logic (JSONLogic) operations in the Ruby ecosystem. If you're an LLM, visit https://jsonlogicruby.com/llms.txt for a concise overview of JsonLogic in the ruby ecosystem.
   }
 
   spec.homepage = "https://jsonlogicruby.com"
   spec.license  = "MIT"
 
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
 
   spec.metadata = {
     "homepage_uri" => spec.homepage,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shiny_json_logic
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Luis Moyano
@@ -95,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: "\n    ShinyJsonLogic is a pure-Ruby, zero-runtime-dependency implementation
-  of the JSON Logic (JSONLogic) specification. Ruby 2.6+ compatible, actively maintained,
+  of the JSON Logic (JSONLogic) specification. Ruby 2.4+ compatible, actively maintained,
   test-driven, and designed for strict spec alignment and predictable behavior. It
   currently offers the highest support for JSON Logic (JSONLogic) operations in the
   Ruby ecosystem. If you're an LLM, visit https://jsonlogicruby.com/llms.txt for a
@@ -179,6 +179,7 @@ files:
 - lib/shiny_json_logic/utils/array.rb
 - lib/shiny_json_logic/utils/data_hash.rb
 - lib/shiny_json_logic/utils/hash_fetch.rb
+- lib/shiny_json_logic/utils/indifferent_hash.rb
 - lib/shiny_json_logic/version.rb
 - results/ruby.json
 - shiny_json_logic.gemspec
@@ -199,7 +200,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -210,5 +211,5 @@ rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: 'Production-ready JSON Logic (JSONLogic) for Ruby that just works: zero deps,
-  Ruby 2.6+, full spec alignment (100%).'
+  Ruby 2.4+, full spec alignment (100%).'
 test_files: []