shiny_json_logic 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df6cbb1873a1d4237a634ab972f9da4f2e1b56012f0e9353e34c723746f75655
-  data.tar.gz: b62ce7480cdbab13df690836b3c837b96b360d08fb6cd0c86ee8e743222234bc
+  metadata.gz: 47eab10babd10e80ceeda0d5f5dc857c73a69ae7f36c5a8b09c71984e02c4243
+  data.tar.gz: 21adb41b87070e1ca2438d83fd351f3bf785ad60ce7842f889beea21d2fa7624
 SHA512:
-  metadata.gz: cb846733714d95672c98d615c1474582e5516d13e02becbe13a9839d7571d7f2792235595777464b53c5e4173ea8af49d5d721d09283bfa72ade52f231bb74f7
-  data.tar.gz: 121d271417ace9b145dfc92861e7857ff8c22eb859a7a8d9f2d8ff6b37708a1ee3c55a22f60cf925c1826c41622012848a2a54dd3f4afc9b8084b4ae6424a8e1
+  metadata.gz: 10f5c5bb5bca496e4f2f0957f304658181cec45277fea2bb91f9cd6c8d4901aaa937113a433821c2e728560e84fda5149d88ac5a27b18059452d8156e55b767b
+  data.tar.gz: a4b7d20d5fbcedd32fe347d418a5efddba8adb77fb11ac6caf9dcfb06ff4e7b3585035db905ccb1242c0b1581a2a5957d83b43d76f0fec89f01524d11351e704

data/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Changelog
 
 All notable changes to this project will be documented in this file.
+## [0.3.2] - 2026-02-28
+### Changed
+- Refactors scope stack as an array of arrays in order to improve performance
+
+## [0.3.1] - 2026-02-23
+### Changed
+- Removes operations validation pass for optimization purposes.
+- Refactors Truthiness module for case/when in order to improve performance.
+
+### Added
+- Adds `Utils::DataHash` to differentiate context objects from rule objects allowing operation validity on the fly.
+
 ## [0.3.0] - 2026-02-21
 ### Changed
 - Refactors internal architecture to improve performance by removing instantiation of operations.

data/Gemfile.lock

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

data/lib/shiny_json_logic/engine.rb

@@ -1,21 +1,26 @@
 # frozen_string_literal: true
 
 require "shiny_json_logic/operator_solver"
+require "shiny_json_logic/utils/data_hash"
 
 module ShinyJsonLogic
   module Engine
     OPERATIONS = OperatorSolver::SOLVERS
 
     def self.call(rule, scope_stack)
-      if rule.is_a?(Hash)
+      if rule.is_a?(Utils::DataHash)
+        rule
+      elsif rule.is_a?(Hash)
         return rule if rule.empty?
 
-        operation, args = rule.to_a.first
+        raise Errors::UnknownOperator if rule.size > 1
+
+        operation, args = rule.first
         operation_key = operation.to_s
-        
-        return rule unless OPERATIONS.key?(operation_key)
 
-        OPERATIONS.fetch(operation_key).call(args, scope_stack)
+        raise Errors::UnknownOperator unless OPERATIONS.key?(operation_key)
+
+        OPERATIONS[operation_key].call(args, scope_stack)
       elsif rule.is_a?(Array)
         rule.map { |val| call(val, scope_stack) }
       else
@@ -24,3 +29,4 @@ module ShinyJsonLogic
     end
   end
 end
+

data/lib/shiny_json_logic/operations/val.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "shiny_json_logic/operations/base"
+require "shiny_json_logic/utils/data_hash"
 
 module ShinyJsonLogic
   module Operations
@@ -10,7 +11,7 @@ module ShinyJsonLogic
 
         # {"val": []} or {"val": null} - return current scope
         if raw_keys.empty? || raw_keys == [nil]
-          return scope_stack.current
+          return Utils::DataHash.wrap(scope_stack.current)
         end
 
         # Check if first element is an array (scope navigation syntax)
@@ -23,13 +24,13 @@ module ShinyJsonLogic
           evaluated_keys = remaining_keys.map { |rule| evaluate(rule, scope_stack) }
 
           levels = level_indicator.abs
-          return scope_stack.resolve(levels, *evaluated_keys)
+          return Utils::DataHash.wrap(scope_stack.resolve(levels, *evaluated_keys))
         end
 
         # Normal case: {"val": "key"} or {"val": ["key1", "key2"]}
         keys = raw_keys.map { |rule| evaluate(rule, scope_stack) }
         current_data = scope_stack.current
-        dig_value(current_data, keys)
+        Utils::DataHash.wrap(dig_value(current_data, keys))
       end
 
       def self.dig_value(data, keys)

data/lib/shiny_json_logic/operations/var.rb

@@ -2,6 +2,7 @@
 
 require "shiny_json_logic/truthy"
 require "shiny_json_logic/operations/base"
+require "shiny_json_logic/utils/data_hash"
 
 module ShinyJsonLogic
   module Operations
@@ -12,10 +13,13 @@ module ShinyJsonLogic
         default = items[1] ? evaluate(items[1], scope_stack) : nil
         current_data = scope_stack.current
 
-        return current_data if key.nil? || key == ""
+        if key.nil? || key == ""
+          return Utils::DataHash.wrap(current_data)
+        end
 
         result = fetch_value(current_data, key)
-        result.nil? ? default : result
+        result = result.nil? ? default : result
+        Utils::DataHash.wrap(result)
       rescue
         default || scope_stack.current
       end

data/lib/shiny_json_logic/scope_stack.rb

@@ -21,12 +21,12 @@ module ShinyJsonLogic
 
     def initialize(root_data)
       @root_data = root_data
-      @stack = [{ data: @root_data, index: 0 }]
+      @stack = [[@root_data, 0]]
     end
 
     # Push a new scope onto the stack (when entering an iteration)
     def push(data, index: 0)
-      stack.push({ data: data, index: index })
+      stack.push([data, index])
     end
 
     # Pop the top scope (when exiting an iteration)
@@ -36,7 +36,7 @@ module ShinyJsonLogic
 
     # Returns the current scope's data (top of stack)
     def current
-      stack.last[:data]
+      stack.last[0]
     end
 
     # Resolve a value by going up n levels and then accessing keys
@@ -51,7 +51,7 @@ module ShinyJsonLogic
       scope = stack[target_index]
       return nil unless scope
       
-      data = scope[:data]
+      data = scope[0]
 
       if keys.empty?
         data

data/lib/shiny_json_logic/truthy.rb

@@ -5,13 +5,15 @@
 module ShinyJsonLogic
   module Truthy
     def self.call(subject)
-      return subject if [true, false].include? subject
-      return !subject.zero?	if subject.is_a? Numeric
-      return subject.any? if subject.is_a? Array
-      return !subject.empty? if subject.is_a? String
-      return subject.keys.any? if subject.is_a? Hash
-
-      !subject.nil?
+      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
+      end
     end
   end
 end

data/lib/shiny_json_logic/utils/data_hash.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ShinyJsonLogic
+  module Utils
+    # A Hash subclass that marks its contents as user data (result of var/val).
+    # The Engine uses this to skip operator validation for these values.
+    class DataHash < Hash
+      def self.wrap(obj)
+        return obj unless obj.is_a?(Hash)
+        return obj if obj.is_a?(DataHash)
+
+        result = new
+        obj.each { |k, v| result[k] = v }
+        result
+      end
+    end
+  end
+end

data/lib/shiny_json_logic/version.rb

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

data/lib/shiny_json_logic.rb

@@ -11,17 +11,17 @@ require "shiny_json_logic/scope_stack"
 
 module ShinyJsonLogic
   def self.apply(rule, data = {})
-    validate_operators!(rule)
-    
     normalized_data = deep_stringify_keys(data || {})
     scope_stack = ScopeStack.new(normalized_data)
     Engine.call(rule, scope_stack)
   end
 
-  # Recursively converts all hash keys to strings
+  # Recursively converts all hash keys to strings.
+  # Fast path: if all keys are already strings, skip the copy.
   def self.deep_stringify_keys(obj)
     case obj
     when Hash
+      return obj if obj.keys.all? { |k| k.is_a?(String) }
       obj.each_with_object({}) do |(key, value), result|
         result[key.to_s] = deep_stringify_keys(value)
       end
@@ -31,31 +31,6 @@ module ShinyJsonLogic
       obj
     end
   end
-
-  # Validates that all operations in the rule tree use known operators
-  def self.validate_operators!(rule)
-    case rule
-    when Hash
-      return if rule.empty?
-      
-      # Multi-key hashes are invalid
-      if rule.size > 1
-        raise Errors::UnknownOperator
-      end
-      
-      operation, args = rule.first
-      
-      # Check if operation is known
-      unless OperatorSolver::SOLVERS.key?(operation.to_s)
-        raise Errors::UnknownOperator
-      end
-      
-      # Recursively validate args
-      validate_operators!(args)
-    when Array
-      rule.each { |item| validate_operators!(item) }
-    end
-  end
 end
 
 JsonLogic = ShinyJsonLogic

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shiny_json_logic
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Luis Moyano
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-21 00:00:00.000000000 Z
+date: 2026-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -177,6 +177,7 @@ files:
 - lib/shiny_json_logic/scope_stack.rb
 - lib/shiny_json_logic/truthy.rb
 - lib/shiny_json_logic/utils/array.rb
+- lib/shiny_json_logic/utils/data_hash.rb
 - lib/shiny_json_logic/version.rb
 - results/ruby.json
 - shiny_json_logic.gemspec