json-logic-rb 0.1.5 → 0.2.0

data/lib/json_logic/operations/strict_not_equal.rb

@@ -2,10 +2,31 @@
 
 using JsonLogic::Semantics
 
-class JsonLogic::Operations::StrictNotEqual < JsonLogic::Operation
+class JsonLogic::Operations::StrictNotEqual < JsonLogic::LazyOperation
   def self.name = "!=="
 
-  def call((a,b), _data)
-    !(a === b)
+  def call(args, data)
+    raise JsonLogic::InvalidArgumentsError.new unless args.is_a?(Array) && args.size >= 2
+
+    prev = JsonLogic.apply(args.first, data)
+    args[1..].each do |arg|
+      current = JsonLogic.apply(arg, data)
+      return false if strict_equal_value?(prev, current)
+
+      prev = current
+    end
+    true
+  end
+
+  private
+
+  def strict_equal_value?(left, right)
+    if left.is_a?(Numeric) && right.is_a?(Numeric)
+      left.to_f == right.to_f
+    elsif left.is_a?(Array) || left.is_a?(Hash)
+      left.equal?(right)
+    else
+      left.class == right.class && left.eql?(right)
+    end
   end
 end

data/lib/json_logic/operations/sub.rb

@@ -1,6 +1,13 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::Sub < JsonLogic::Operation
   def self.name = "-"
-  def call(values, _data) = (values.size == 1 ? -values[0].to_f : values[0].to_f - values[1].to_f)
+
+  def call(args, _data)
+    raise JsonLogic::InvalidArgumentsError.new if args.empty?
+    numbers = args.map(&:to_f)
+    numbers.one? ? -numbers.first : numbers.drop(1).reduce(numbers.first, :-)
+  end
 end

data/lib/json_logic/operations/substr.rb

@@ -1,30 +1,22 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::Substr < JsonLogic::Operation
   def self.name = "substr"
 
-  def call(values, _data)
-    s, i, len = values
-    str   = s.to_s
-    start = i.to_i
+  def call((string, index, length), _data)
+    value = string.to_s
+    start = index.to_i
+    start += value.length if start.negative?
+    start = start.clamp(0, value.length)
 
-    start += str.length if start < 0
-    start = 0 if start < 0
-    start = str.length if start > str.length
+    return value[start..] || "" if length.nil?
 
-    return (str[start..-1] || "") if len.nil?
+    size = length.to_i
+    return value.slice(start, size) || "" unless size.negative?
 
-    l = len.to_i
-    if l >= 0
-      slice = str[start, l]
-      slice.nil? ? "" : slice
-    else
-      end_excl = str.length + l
-      end_excl = start if end_excl < start
-      end_excl = str.length if end_excl > str.length
-      length = end_excl - start
-      length = 0 if length < 0
-      str[start, length] || ""
-    end
+    finish = (value.length + size).clamp(start, value.length)
+    value.slice(start...finish) || ""
   end
 end

data/lib/json_logic/operations/ternary.rb

@@ -5,11 +5,5 @@ using JsonLogic::Semantics
 class JsonLogic::Operations::Ternary < JsonLogic::LazyOperation
   def self.name = "?:"
 
-  def call((cond_rule, then_rule, else_rule), data)
-    if !!JsonLogic.apply(cond_rule, data)
-      JsonLogic.apply(then_rule, data)
-    else
-      JsonLogic.apply(else_rule, data)
-    end
-  end
+  def call((cond_rule, then_rule, else_rule), data) = !!JsonLogic.apply(cond_rule, data) ? JsonLogic.apply(then_rule, data) : JsonLogic.apply(else_rule, data)
 end

data/lib/json_logic/operations/throw.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+using JsonLogic::Semantics
+
+class JsonLogic::Operations::Throw < JsonLogic::Operation
+  def self.name = "throw"
+
+  def call((value), _data)
+    type = value.is_a?(Hash) ? (value["type"] || value[:type]).to_s : value.to_s
+    raise JsonLogic::Error, type
+  end
+end

data/lib/json_logic/operations/try.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+using JsonLogic::Semantics
+
+class JsonLogic::Operations::Try < JsonLogic::LazyOperation
+  def self.name = "try"
+
+  def call(arguments, data)
+    arguments = Array.wrap(arguments)
+    raise JsonLogic::InvalidArgumentsError.new if arguments.empty?
+
+    state = { data: data, error: nil }
+
+    arguments.each do |expression|
+      begin
+        value = JsonLogic.apply(expression, state[:data])
+        return value unless value.is_a?(Float) && value.nan?
+
+        state[:error] = JsonLogic::NaNError.new
+      rescue JsonLogic::Error => error
+        state[:error] = error
+      rescue ArgumentError, IndexError, TypeError, NoMethodError
+        state[:error] = JsonLogic::InvalidArgumentsError.new
+      rescue ZeroDivisionError, FloatDomainError
+        state[:error] = JsonLogic::NaNError.new
+      rescue StandardError => error
+        state[:error] = JsonLogic::Error.new(error.message)
+      end
+
+      state[:data] = state[:error].payload
+    end
+
+    raise state[:error]
+  end
+end

data/lib/json_logic/operations/val.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+using JsonLogic::Semantics
+
+class JsonLogic::Operations::Val < JsonLogic::Operation
+  def self.name = "val"
+  def self.values_only? = false
+
+  def call(args, data)
+    path = JsonLogic.apply(path_rule(args), data)
+    return root_value(path, data) if root_path?(path)
+
+    base, segments = resolve_base_and_segments(path, data)
+    JsonLogic::Tree.new(base).dig(segments, split_dots: false)
+  end
+
+  private
+
+  def path_rule(args) = args.is_a?(Array) && args.one? ? args.first : args
+
+  def root_path?(path)
+    path.nil? || (path.is_a?(Array) && path.empty?) || (path.is_a?(String) && path.empty?)
+  end
+
+  def root_value(path, data)
+    return data if path.nil?
+    return scoped_root_value(data) if path.is_a?(Array) && path.empty?
+    return data[""] if data.is_a?(Hash) && data.key?("")
+
+    data
+  end
+
+  def scoped_root_value(data)
+    return data[""] if data.is_a?(Hash) && data["__scope__"] && data.key?("")
+
+    data
+  end
+
+  def resolve_base_and_segments(path, data)
+    segments = path.is_a?(Array) ? path : [path]
+    return [data, segments] unless segments.first.is_a?(Array)
+
+    hop = segments.first.first.to_i
+    [base_for_hop(data, hop), segments.drop(1)]
+  end
+
+  def base_for_hop(base, hop)
+    return base if hop.zero?
+    return base_for_positive_hop(base, hop) if hop.positive?
+
+    (-hop - 1).times do
+      parent = parent_of(base)
+      break unless parent
+
+      base = parent
+    end
+    base
+  end
+
+  def base_for_positive_hop(base, hop)
+    moved = false
+    (hop - 1).times do
+      parent = parent_of(base)
+      break unless parent
+
+      base = parent
+      moved = true
+    end
+    return base if moved
+
+    stack = Thread.current[:json_logic_scope_stack] || []
+    idx = stack.length - hop
+    return base unless idx >= 0 && idx < stack.length
+
+    stack[idx]
+  end
+
+  def parent_of(value) = value.is_a?(Hash) ? value["__parent__"] : nil
+end

data/lib/json_logic/operations/var.rb

@@ -1,30 +1,32 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::Var < JsonLogic::Operation
-  def self.name = "var";
+  def self.name = "var"
   def self.values_only? = false
 
-  def call((path_rule, fallback_rule), data)
+  def call(args, data)
+    json = JsonLogic::Tree.new(data)
+
+    if args.is_a?(Array)
+      path_rule = args[0]
+      fallback_rule = args[1]
+    else
+      path_rule = args
+      fallback_rule = nil
+    end
+
     path = JsonLogic.apply(path_rule, data)
-    return data if path == ""
-    val = dig(data, path)
-    return val unless val.nil?
+    if path.is_a?(String) && path.empty?
+      return data[""] if data.is_a?(Hash) && data.key?("")
+      return data
+    end
+
+    return json.dig(path, split_dots: true) if json.exists?(path, split_dots: true)
+
     return nil if fallback_rule.nil?
-    JsonLogic.apply(fallback_rule, data)
-  end
 
-  def dig(obj, path)
-    return nil if obj.nil?
-    cur = obj
-    path.to_s.split(".").each do |k|
-      if cur.is_a?(Array) && k =~ /\A\d+\z/
-        cur = cur[k.to_i]
-      elsif cur.is_a?(Hash)
-        cur = cur[k] || cur[k.to_s] || cur[k.to_sym]
-      else
-        return nil
-      end
-    end
-    cur
+    JsonLogic.apply(fallback_rule, data)
   end
 end

data/lib/json_logic/scope.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module JsonLogic
+  # Per-item evaluation scope for enumerable operations.
+  # Keeps meta-fields virtual so they are not written into item hashes.
+  class Scope < Hash
+    ROOT_KEY = ""
+    VALUE_KEY = "value"
+    INDEX_KEY = "index"
+    PARENT_KEY = "__parent__"
+    SCOPE_KEY = "__scope__"
+
+    def initialize(item, parent, index)
+      super()
+      update(item) if item.is_a?(Hash)
+      @item = item
+      @parent = parent
+      @index = index
+    end
+
+    def [](key)
+      normalized = normalize_key(key)
+      return @parent if normalized == PARENT_KEY
+      return true if normalized == SCOPE_KEY
+
+      if super_key?(normalized)
+        super(normalized)
+      else
+        virtual_value(normalized)
+      end
+    end
+
+    def key?(key)
+      normalized = normalize_key(key)
+      return true if normalized == PARENT_KEY || normalized == SCOPE_KEY
+      return true if normalized == ROOT_KEY || normalized == VALUE_KEY || normalized == INDEX_KEY
+      return true if super_key?(normalized)
+
+      !virtual_value(normalized).nil?
+    end
+
+    private
+
+    def normalize_key(key)
+      case key
+      when Symbol then key.to_s
+      else key
+      end
+    end
+
+    def super_key?(key)
+      hash_has_key?(key) || (key.is_a?(String) && hash_has_key?(key.to_sym))
+    end
+
+    def hash_has_key?(key)
+      Hash.instance_method(:key?).bind_call(self, key)
+    end
+
+    def virtual_value(key)
+      return @item if key == ROOT_KEY
+      return @item if key == VALUE_KEY
+      return @index if key == INDEX_KEY
+
+      nil
+    end
+  end
+end

data/lib/json_logic/semantics.rb

@@ -34,7 +34,7 @@ module JsonLogic
       when TrueClass  then 1.0
       when FalseClass then 0.0
       when NilClass   then 0.0
-      when Array      then num(to_primitive(v))
+      when Array      then Float::NAN
       when String
         s = v.strip
         return 0.0 if s.empty?
@@ -49,41 +49,14 @@ module JsonLogic
     end
 
     def eq(a, b)
-      if a.class == b.class
-        if a.is_a?(Numeric)
-          ax = a.to_f; bx = b.to_f
-          return false if ax.nan? || bx.nan?
-          return ax == bx
-        else
-          return a.eql?(b)
-        end
-      end
-
-      if a.nil? && b.nil?
-        return true
-      elsif a.nil? || b.nil?
-        return false
-      end
+      return a.eql?(b) if a.is_a?(String) && b.is_a?(String)
+      raise FloatDomainError, "NaN" if a.is_a?(Array) || b.is_a?(Array) || a.is_a?(Hash) || b.is_a?(Hash)
 
-      if a.is_a?(TrueClass) || a.is_a?(FalseClass)
-        return eq(num(a), b)
-      end
-      if b.is_a?(TrueClass) || b.is_a?(FalseClass)
-        return eq(a, num(b))
-      end
+      ax = num(a)
+      bx = num(b)
+      raise FloatDomainError, "NaN" if ax.nan? || bx.nan?
 
-      if (a.is_a?(String) && b.is_a?(Numeric)) || (a.is_a?(Numeric) && b.is_a?(String))
-        ax = num(a); bx = num(b)
-        return false if ax.nan? || bx.nan?
-        return ax == bx
-      end
-
-      if (a.is_a?(Array) && (b.is_a?(String) || b.is_a?(Numeric))) ||
-         (b.is_a?(Array) && (a.is_a?(String) || a.is_a?(Numeric)))
-        return eq(to_primitive(a), to_primitive(b))
-      end
-
-      false
+      ax == bx
     end
 
     def cmp(a, b)
@@ -96,6 +69,13 @@ module JsonLogic
       end
     end
 
+    def cmp!(a, b)
+      c = cmp(a, b)
+      raise FloatDomainError, "NaN" if c.nil?
+
+      c
+    end
+
     refine Object do
       def !@
         JsonLogic::Semantics.truthy?(self) ? false : true
@@ -108,11 +88,100 @@ module JsonLogic
 
     [String, Integer, Float, NilClass, Array, TrueClass, FalseClass].each do |klass|
       refine klass do
+        def to_f
+          case self
+          when Integer, Float
+            self * 1.0
+          when TrueClass
+            1.0
+          when FalseClass, NilClass
+            0.0
+          when String
+            s = strip
+            return 0.0 if s.empty?
+            Float(s)
+          when Array
+            raise FloatDomainError, "NaN"
+          else
+            raise FloatDomainError, "NaN"
+          end
+        rescue ArgumentError
+          raise FloatDomainError, "NaN"
+        end
+
         def ==(other) = JsonLogic::Semantics.eq(self, other)
-        def >(other)  = (c = JsonLogic::Semantics.cmp(self, other)) && c == 1
-        def >=(other) = (c = JsonLogic::Semantics.cmp(self, other)) && (c == 1 || c == 0)
-        def <(other)  = (c = JsonLogic::Semantics.cmp(self, other)) && c == -1
-        def <=(other) = (c = JsonLogic::Semantics.cmp(self, other)) && (c == -1 || c == 0)
+        def >(other)
+          case JsonLogic::Semantics.cmp!(self, other)
+          when 1 then true
+          else false
+          end
+        end
+
+        def >=(other)
+          case JsonLogic::Semantics.cmp!(self, other)
+          when 1, 0 then true
+          else false
+          end
+        end
+
+        def <(other)
+          case JsonLogic::Semantics.cmp!(self, other)
+          when -1 then true
+          else false
+          end
+        end
+
+        def <=(other)
+          case JsonLogic::Semantics.cmp!(self, other)
+          when -1, 0 then true
+          else false
+          end
+        end
+      end
+    end
+
+    refine Hash do
+      def to_f
+        raise FloatDomainError, "NaN"
+      end
+
+      def ==(other)
+        return eql?(other) if other.is_a?(Hash)
+        JsonLogic::Semantics.eq(self, other)
+      end
+
+      def >(other)
+        case JsonLogic::Semantics.cmp!(self, other)
+        when 1 then true
+        else false
+        end
+      end
+
+      def >=(other)
+        case JsonLogic::Semantics.cmp!(self, other)
+        when 1, 0 then true
+        else false
+        end
+      end
+
+      def <(other)
+        case JsonLogic::Semantics.cmp!(self, other)
+        when -1 then true
+        else false
+        end
+      end
+
+      def <=(other)
+        case JsonLogic::Semantics.cmp!(self, other)
+        when -1, 0 then true
+        else false
+        end
+      end
+    end
+
+    refine Object do
+      def to_f
+        raise FloatDomainError, "NaN"
       end
     end
   end

data/lib/json_logic/tree.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module JsonLogic
+  class Tree
+    INDEX_PATTERN = /\A-?\d+\z/
+
+    def initialize(data)
+      @data = data
+    end
+
+    def dig(path, split_dots: true)
+      _found, value = lookup(path, split_dots: split_dots)
+      value
+    end
+
+    def exists?(path, split_dots: true)
+      lookup(path, split_dots: split_dots).first
+    end
+
+    private
+
+    def lookup(path, split_dots: true)
+      return [true, @data] if root_path?(path)
+
+      current = @data
+      each_segment(path, split_dots: split_dots).each do |segment|
+        found, current = step(current, segment)
+        return [false, nil] unless found
+      end
+
+      [true, current]
+    end
+
+    def root_path?(path)
+      path.nil? || (path.is_a?(String) && path.empty?) || (path.is_a?(Array) && path.empty?)
+    end
+
+    def step(current, segment)
+      case current
+      when Hash
+        fetch_from_hash(current, segment)
+      when Array
+        fetch_from_array(current, segment)
+      else
+        [false, nil]
+      end
+    end
+
+    def fetch_from_hash(current, segment)
+      key = find_hash_key(current, segment)
+      return [false, nil] if key.nil?
+
+      [true, current[key]]
+    end
+
+    def find_hash_key(current, segment)
+      keys = [segment]
+      keys << segment.to_sym if segment.is_a?(String)
+      keys << segment.to_s
+      keys.find { |key| current.key?(key) }
+    end
+
+    def fetch_from_array(current, segment)
+      index = normalize_index(segment, current.length)
+      return [false, nil] if index.nil?
+
+      [true, current[index]]
+    end
+
+    def each_segment(path, split_dots: true)
+      case path
+      when Array
+        path.flat_map { |segment| split_segment(segment, split_dots: split_dots) }
+      else
+        split_segment(path, split_dots: split_dots)
+      end
+    end
+
+    def split_segment(segment, split_dots: true)
+      if split_dots && segment.is_a?(String) && !segment.empty? && !segment.eql?(".")
+        segment.split('.')
+      else
+        [segment]
+      end
+    end
+
+    def normalize_index(segment, size)
+      return nil unless segment.to_s.match?(INDEX_PATTERN)
+
+      idx = segment.to_i
+      idx += size if idx.negative?
+      return nil if idx.negative? || idx >= size
+
+      idx
+    end
+  end
+end

data/lib/json_logic/version.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-module JsonLogic; VERSION = '0.1.5'; end
+module JsonLogic; VERSION = '0.2.0'; end

data/lib/json_logic.rb

@@ -2,6 +2,13 @@
 
 require_relative 'json_logic/version'
 require_relative 'json_logic/semantics'
+require_relative 'json_logic/errors/error'
+require_relative 'json_logic/errors/logic_error'
+require_relative 'json_logic/errors/invalid_arguments_error'
+require_relative 'json_logic/errors/nan_error'
+require_relative 'json_logic/ext/array'
+require_relative 'json_logic/tree'
+require_relative 'json_logic/scope'
 require_relative 'json_logic/operation'
 require_relative 'json_logic/lazy_operation'
 require_relative 'json_logic/enumerable_operation'
@@ -34,7 +41,12 @@ module JsonLogic
 
   class << self
     def apply(rule, data = nil)
+      stack = (Thread.current[:json_logic_scope_stack] ||= [])
+      stack << data
       Engine.default.evaluate(rule, data)
+    ensure
+      stack.pop
+      Thread.current[:json_logic_scope_stack] = nil if stack.empty?
     end
 
     def add_operation(name, lazy: false, &block)

data/script/build_tests_json.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'json'
+
+source_dir = ARGV[0] || '/tmp/compat-tables/suites'
+out_file = ARGV[1] || File.expand_path('../spec/tmp/tests.json', __dir__)
+
+index_file = File.join(source_dir, 'index.json')
+abort("index.json not found at #{index_file}") unless File.exist?(index_file)
+
+index = JSON.parse(File.read(index_file))
+merged = []
+
+index.each do |relative_path|
+  suite_file = File.join(source_dir, relative_path)
+  abort("suite file not found: #{suite_file}") unless File.exist?(suite_file)
+
+  merged << "# suite: #{relative_path}"
+  suite_entries = JSON.parse(File.read(suite_file))
+  suite_entries.each { |entry| merged << entry }
+end
+
+File.write(out_file, JSON.pretty_generate(merged) + "\n")
+case_count = merged.count { |entry| entry.is_a?(Hash) && entry.key?('rule') }
+puts "Wrote #{out_file} with #{case_count} rule cases from #{index.size} suites"