shiny_json_logic 0.2.16 → 0.3.1

data/lib/shiny_json_logic/operations/subtraction.rb

@@ -7,18 +7,20 @@ require "shiny_json_logic/numericals/numerify"
 module ShinyJsonLogic
   module Operations
     class Subtraction < 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?
 
         safe_arithmetic do
           result = nil
           count = 0
 
-          each_operand(operands) do |num|
+          operands.each do |rule|
+            evaluated = evaluate(rule, scope_stack)
+            num = Numericals::Numerify.numerify(evaluated)
+            num = 0 if num.nil?
             count += 1
             result = result.nil? ? num : result - num
           end
@@ -29,21 +31,6 @@ module ShinyJsonLogic
           result
         end
       end
-
-      private
-
-      def each_operand(operands)
-        operands.each do |rule|
-          evaluated = evaluate(rule)
-          yield numerify(evaluated)
-        end
-      end
-
-      def numerify(value)
-        val = super
-        return 0 if val.nil?
-        val
-      end
     end
   end
 end

data/lib/shiny_json_logic/operations/throw.rb

@@ -5,22 +5,20 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Throw < Base
-      def call
+      def self.execute(rules, scope_stack)
         raw_value = rules.is_a?(Array) ? rules[0] : rules
 
         error_type =
-          if operation?(raw_value)
-            evaluate(raw_value)
+          if op?(raw_value)
+            evaluate(raw_value, scope_stack)
           else
             raw_value
           end
 
         extracted_type = error_type.is_a?(Hash) && error_type.key?("type") ? error_type["type"] : error_type
-        extracted_type = self.data["type"] if extracted_type.nil?
+        extracted_type = scope_stack.current["type"] if extracted_type.nil?
 
-        error = Errors::Base.new(type: extracted_type)
-
-        raise error
+        raise Errors::Base.new(type: extracted_type)
       end
     end
   end

data/lib/shiny_json_logic/operations/try.rb

@@ -3,8 +3,8 @@
 module ShinyJsonLogic
   module Operations
     class Try < Base
-      def call
-        items = wrap_nil(rules)
+      def self.call(rules, scope_stack)
+        items = Utils::Array.wrap_nil(rules)
         last_error = nil
 
         items.each do |item|
@@ -33,7 +33,6 @@ module ShinyJsonLogic
             end
 
             last_error = e
-            # Don't add to errors array - we're handling it
           end
         end
 

data/lib/shiny_json_logic/operations/val.rb

@@ -1,56 +1,48 @@
 # frozen_string_literal: true
 
 require "shiny_json_logic/operations/base"
+require "shiny_json_logic/utils/data_hash"
 
 module ShinyJsonLogic
   module Operations
     class Val < Base
-      def call
-        raw_keys = wrap_nil(rules)
-        
+      def self.execute(rules, scope_stack)
+        raw_keys = Utils::Array.wrap_nil(rules)
+
         # {"val": []} or {"val": null} - return current scope
         if raw_keys.empty? || raw_keys == [nil]
-          return scope_stack ? scope_stack.current : data
+          return Utils::DataHash.wrap(scope_stack.current)
         end
 
         # Check if first element is an array (scope navigation syntax)
-        # {"val": [[N], "key"]} - scope navigation
         first_key = raw_keys.first
-        
+
         if first_key.is_a?(Array) && scope_stack
           level_indicator = first_key.first.to_i
           remaining_keys = raw_keys[1..]
-          
-          # Evaluate any remaining keys that might be operations
-          evaluated_keys = remaining_keys.map { |rule| evaluate(rule) }
-          
-          # Both positive and negative numbers mean "go up N levels"
-          # [[2], "key"] = go up 2 levels
-          # [[-2], "key"] = go up 2 levels (same as above)
+
+          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) }
-        current_data = scope_stack ? scope_stack.current : data
-        dig_value(current_data, keys)
+        keys = raw_keys.map { |rule| evaluate(rule, scope_stack) }
+        current_data = scope_stack.current
+        Utils::DataHash.wrap(dig_value(current_data, keys))
       end
 
-      private
-
-      def dig_value(data, keys)
+      def self.dig_value(data, keys)
         return nil if data.nil?
         return data if keys.empty?
-        
+
         keys.reduce(data) do |obj, key|
           return nil if obj.nil?
-          
+
           if obj.is_a?(Hash)
-            # Normalize key to string for lookup (data is already string-keyed)
             obj[key.to_s]
           elsif obj.is_a?(Array)
-            # Convert string keys to integers for arrays
             index = key.is_a?(String) ? key.to_i : key
             obj[index]
           else
@@ -58,6 +50,7 @@ module ShinyJsonLogic
           end
         end
       end
+      private_class_method :dig_value
     end
   end
 end

data/lib/shiny_json_logic/operations/var.rb

@@ -2,36 +2,37 @@
 
 require "shiny_json_logic/truthy"
 require "shiny_json_logic/operations/base"
+require "shiny_json_logic/utils/data_hash"
 
 module ShinyJsonLogic
   module Operations
     class Var < Base
-      def call
-        items = wrap_nil(rules)
-        key = evaluate(items[0])
-        default = items[1] ? evaluate(items[1]) : nil
+      def self.execute(rules, scope_stack)
+        items = Utils::Array.wrap_nil(rules)
+        key = evaluate(items[0], scope_stack)
+        default = items[1] ? evaluate(items[1], scope_stack) : nil
+        current_data = scope_stack.current
 
-        return data if key.nil? || key == ""
+        if key.nil? || key == ""
+          return Utils::DataHash.wrap(current_data)
+        end
 
-        result = fetch_value(data, key)
-        result.nil? ? default : result
+        result = fetch_value(current_data, key)
+        result = result.nil? ? default : result
+        Utils::DataHash.wrap(result)
       rescue
-        default || data
+        default || scope_stack.current
       end
 
-      private
-
-      def fetch_value(obj, key)
+      def self.fetch_value(obj, key)
         return nil if obj.nil?
-        
-        # Split dot-separated keys
+
         keys = key.to_s.split('.')
-        
+
         keys.reduce(obj) do |current, k|
           return nil if current.nil?
-          
+
           if current.is_a?(Hash)
-            # Data is already normalized to string keys
             current[k]
           elsif current.is_a?(Array)
             current[k.to_i]
@@ -40,6 +41,7 @@ module ShinyJsonLogic
           end
         end
       end
+      private_class_method :fetch_value
     end
   end
 end

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.2.16"
+  VERSION = "0.3.1"
 end

data/lib/shiny_json_logic.rb

@@ -11,8 +11,6 @@ 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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shiny_json_logic
 version: !ruby/object:Gem::Version
-  version: 0.2.16
+  version: 0.3.1
 platform: ruby
 authors:
 - Luis Moyano
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-21 00:00:00.000000000 Z
+date: 2026-02-23 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