json-logic-rb 0.1.0.beta1

data/lib/json_logic/operations/missing_some.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class JsonLogic::Operations::MissingSome < JsonLogic::Operation
+  def self.op_name = "missing_some"
+
+  def call((min_ok, list), data)
+    arr = list.is_a?(Array) ? list : Array(list)
+    missing = arr.select { |k| dig(data, k).nil? }
+    (arr.size - missing.size) >= min_ok ? [] : missing
+  end
+
+  private
+  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
+  end
+end

data/lib/json_logic/operations/mod.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class JsonLogic::Operations::Mod < JsonLogic::Operation
+  def self.op_name = "%"
+  def call((a,b), _data) = a.to_f % b.to_f
+end

data/lib/json_logic/operations/mul.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class JsonLogic::Operations::Mul < JsonLogic::Operation
+  def self.op_name = "*"
+  def call(values, _data) = values.map!(&:to_f).inject(1){|m,v| m * v }
+end

data/lib/json_logic/operations/none.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class JsonLogic::Operations::None < JsonLogic::EnumerableOperation
+  def self.op_name = "none"
+
+  def call(args, data)
+    items, rule_applied_to_each_item = resolve_items_and_per_item_rule(args, data)
+    items.none? do |item|
+      JsonLogic::Semantics.truthy?(
+        JsonLogic.apply(rule_applied_to_each_item, item)
+      )
+    end
+  end
+end

data/lib/json_logic/operations/not.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class JsonLogic::Operations::Not < JsonLogic::Operation
+  def self.op_name = "!";
+  def call((a), _data) = !JsonLogic::Semantics.truthy?(a)
+end

data/lib/json_logic/operations/not_equal.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class JsonLogic::Operations::NotEqual < JsonLogic::Operation
+  def self.op_name = "!="
+  def call((a,b), _data) = !JsonLogic::Semantics.loose_equal(a,b)
+end

data/lib/json_logic/operations/or.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+class JsonLogic::Operations::Or < JsonLogic::LazyOperation
+  def self.op_name = "or"
+
+  def call(args, data)
+    args.each do |a|
+      v = JsonLogic.apply(a, data)
+      return v if JsonLogic::Semantics.truthy?(v)
+    end
+    args.empty? ? nil : JsonLogic.apply(args.last, data)
+  end
+end

data/lib/json_logic/operations/reduce.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class JsonLogic::Operations::Reduce < JsonLogic::EnumerableOperation
+  def self.op_name = "reduce"
+
+  def call(args, data)
+    rule_that_returns_items, step_rule_applied_per_item, rule_that_returns_initial_accumulator = args
+
+    items = Array(JsonLogic.apply(rule_that_returns_items, data))
+    acc   = JsonLogic.apply(rule_that_returns_initial_accumulator, data)
+
+    items.reduce(acc) do |memo, item|
+      JsonLogic.apply(
+        step_rule_applied_per_item,
+        (data || {}).merge("" => item, "current" => item, "accumulator" => memo)
+      )
+    end
+  end
+end

data/lib/json_logic/operations/some.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: tru
+
+class JsonLogic::Operations::Some < JsonLogic::EnumerableOperation
+  def self.op_name = "some"
+
+  def call(args, data)
+    items, rule_applied_to_each_item = resolve_items_and_per_item_rule(args, data)
+    return false if items.empty?
+
+    items.any? do |item|
+      JsonLogic::Semantics.truthy?(
+        JsonLogic.apply(rule_applied_to_each_item, item)
+      )
+    end
+  end
+end

data/lib/json_logic/operations/strict_equal.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class JsonLogic::Operations::StrictEqual < JsonLogic::Operation
+  def self.op_name = "==="
+  def call((a,b), _data) = JsonLogic::Semantics.strict_equal(a,b)
+end

data/lib/json_logic/operations/strict_not_equal.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class JsonLogic::Operations::StrictNotEqual < JsonLogic::Operation
+  def self.op_name = "!=="
+  def call((a,b), _data) = !JsonLogic::Semantics.strict_equal(a,b)
+end

data/lib/json_logic/operations/sub.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class JsonLogic::Operations::Sub < JsonLogic::Operation
+  def self.op_name = "-"
+  def call(values, _data) = (values.size == 1 ? -values[0].to_f : values[0].to_f - values[1].to_f)
+end

data/lib/json_logic/operations/substr.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class JsonLogic::Operations::Substr < JsonLogic::Operation
+  def self.op_name = "substr"
+
+  def call(values, _data)
+    s, i, len = values
+    str   = s.to_s
+    start = i.to_i
+
+    start += str.length if start < 0
+    start = 0 if start < 0
+    start = str.length if start > str.length
+
+    return (str[start..-1] || "") if len.nil?
+
+    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
+  end
+end

data/lib/json_logic/operations/ternary.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class JsonLogic::Operations::Ternary < JsonLogic::LazyOperation
+  def self.op_name = "?:"
+
+  def call((cond_rule, then_rule, else_rule), data)
+    if JsonLogic::Semantics.truthy?(JsonLogic.apply(cond_rule, data))
+      JsonLogic.apply(then_rule, data)
+    else
+      JsonLogic.apply(else_rule, data)
+    end
+  end
+end

data/lib/json_logic/operations/var.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class JsonLogic::Operations::Var < JsonLogic::Operation
+  def self.op_name = "var"; def self.values_only? = false
+  def call((path_rule, fallback_rule), data)
+    path = JsonLogic.apply(path_rule, data)
+    return data if path == ""
+    val = dig(data, path)
+    return val unless val.nil?
+    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
+  end
+end

data/lib/json_logic/registry.rb

@@ -0,0 +1,19 @@
+# lib/json_logic/registry.rb
+
+module JsonLogic
+  class Registry
+    def initialize(map = {})
+      @map = map.dup
+    end
+
+    def register(op_class)
+      name = op_class.op_name or raise ArgumentError, 'op_name missing'
+      @map[name.to_s] = op_class
+      self
+    end
+
+    def fetch(name)
+      @map[name.to_s]
+    end
+  end
+end

data/lib/json_logic/semantics.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module JsonLogic
+  module Semantics
+    module_function
+
+    def truthy?(v)
+      case v
+      when nil then false
+      when TrueClass, FalseClass then v
+      when Numeric then !v.zero?
+      when String then !v.empty?
+      when Array  then !v.empty?
+      else true
+      end
+    end
+
+    def falsy?(v) = !truthy?(v)
+
+    def to_number(v)
+      return v.to_f if v.is_a?(Numeric) || v.is_a?(String)
+      v.to_s.to_f
+    end
+
+    def strict_equal(a,b)
+      if a.is_a?(Numeric) && b.is_a?(Numeric)
+        a.to_f == b.to_f
+      else
+        a.class == b.class && a == b
+      end
+    end
+
+    def loose_equal(a,b)
+      if (a.is_a?(Numeric)||a.is_a?(String)) && (b.is_a?(Numeric)||b.is_a?(String))
+        to_number(a) == to_number(b)
+      else
+        a == b
+      end
+    end
+  end
+end

data/lib/json_logic/version.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+module JsonLogic; VERSION = '0.1.0.beta1'; end

data/lib/json_logic.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'json_logic/version'
+require_relative 'json_logic/semantics'
+require_relative 'json_logic/operation'
+require_relative 'json_logic/lazy_operation'
+require_relative 'json_logic/enumerable_operation'
+require_relative 'json_logic/registry'
+require_relative 'json_logic/engine'
+
+module JsonLogic
+  module Operations
+  end
+end
+
+
+# Load operation classes (each file defines one class with .op_name)
+Dir[File.join(__dir__, 'json_logic', 'operations', '*.rb')].sort.each { |f| require f }
+
+# Auto-register all operation classes with .op_name
+module JsonLogic
+  module Loader
+    module_function
+
+    def register_all!(registry)
+      ObjectSpace.each_object(Class) do |klass|
+        next unless klass < JsonLogic::Operation
+        next unless klass.respond_to?(:op_name) && klass.op_name && !klass.op_name.to_s.empty?
+
+        registry.register(klass)
+      end
+    end
+  end
+
+  class << self
+    def apply(rule, data = nil)
+      Engine.default.evaluate(rule, data)
+    end
+  end
+end
+
+JsonLogic::Loader.register_all!(JsonLogic::Engine.default.registry)

data/script/compliance.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../lib/json_logic'
+require 'json'
+
+path = ARGV[0] || File.expand_path('../spec/tmp/tests.json', __dir__)
+abort("tests.json not found at #{path}") unless File.exist?(path)
+
+payload = JSON.parse(File.read(path))
+
+extract = lambda do |x|
+  if x.is_a?(Array) && [2, 3].include?(x.size) && (x[0].is_a?(Hash) || x[0].is_a?(Array))
+    rule, a2, a3 = x
+    data, exp = (x.size == 2 ? [nil, a2] : [a2, a3])
+    [rule, data, exp]
+  elsif x.is_a?(Hash) && x.key?('rule')
+    [x['rule'], x['data'], x['result'] || x['expected']]
+  end
+end
+
+cases = []
+stack = [payload]
+while (n = stack.pop)
+  if (c = extract.call(n))
+    cases << c
+  elsif n.is_a?(Array)
+    n.size == 2 && n[0].is_a?(String) && n[1].is_a?(Array) ? stack << n[1] : n.each { |e| stack << e }
+  elsif n.is_a?(Hash)
+    n.each_value { |v| stack << v }
+  end
+end
+abort("No tests found in #{path}") if cases.empty?
+
+total = fail = 0
+cases.each_with_index do |(rule, data, expected), i|
+  total += 1
+  begin
+    got = JsonLogic.apply(rule, data)
+    next if got == expected
+
+    fail += 1
+    puts "[FAIL ##{i + 1}] exp=#{expected.inspect} got=#{got.inspect} rule=#{rule.inspect} data=#{data.inspect}"
+  rescue StandardError => e
+    fail += 1
+    puts "[ERROR ##{i + 1}] #{e.class}: #{e.message} rule=#{rule.inspect} data=#{data.inspect}"
+  end
+end
+
+puts "Compliance: #{total - fail}/#{total} passed"
+exit(fail.zero? ? 0 : 1)