json-logic-rb 0.1.5 → 0.2.0

data/lib/json_logic/errors/logic_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module JsonLogic
+  class LogicError < Error
+    DEFAULT_MESSAGE = "LogicError"
+  end
+end

data/lib/json_logic/errors/nan_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module JsonLogic
+  class NaNError < Error
+    DEFAULT_MESSAGE = "NaN"
+  end
+end

data/lib/json_logic/ext/array.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Array
+  def self.wrap(value) = value.is_a?(Array) ? value : [value]
+end

data/lib/json_logic/operations/add.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::Add < JsonLogic::Operation
   def self.name = "+"
 
-  def call(values, _data)
-    values.map!(&:to_f).sum
-  end
+  def call(args, _data) = args.map(&:to_f).sum
 end

data/lib/json_logic/operations/all.rb

@@ -5,12 +5,9 @@ using JsonLogic::Semantics
 class JsonLogic::Operations::All < JsonLogic::EnumerableOperation
   def self.name = "all"
 
-  def call(args, data)
-    items, rule_applied_to_each_item = resolve_items_and_per_item_rule(args, data)
-    return false if items.empty?
+  protected
 
-    items.all? do |item|
-      !!JsonLogic.apply(rule_applied_to_each_item, item)
-    end
+  def call_with_values(values)
+    !values.empty? && values.all? { |value| !!value }
   end
 end

data/lib/json_logic/operations/and.rb

@@ -6,11 +6,12 @@ class JsonLogic::Operations::And < JsonLogic::LazyOperation
   def self.name = "and"
 
   def call(args, data)
-    last = nil
-    args.each do |a|
-      last = JsonLogic.apply(a, data)
-      return last unless !!last
+    raise JsonLogic::InvalidArgumentsError.new unless args.is_a?(Array)
+
+    args.reduce(false) do |_memo, rule|
+      value = JsonLogic.apply(rule, data)
+      break value unless value.to_bool
+      value
     end
-    last
   end
 end

data/lib/json_logic/operations/bool_cast.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
 using JsonLogic::Semantics
+
 class JsonLogic::Operations::BoolCast < JsonLogic::Operation
   def self.name = "!!"
 
-  def call((a), _data)
-    !!a
-  end
+  def call((a), _data) = !!a
 end

data/lib/json_logic/operations/cat.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::Cat < JsonLogic::Operation
   def self.name = "cat"
 
-  def call(values, _data) = values.map!(&:to_s).join
+  def call(args, _data) = args.map!(&:to_s).join
 end

data/lib/json_logic/operations/coalesce.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+using JsonLogic::Semantics
+
+class JsonLogic::Operations::Coalesce < JsonLogic::Operation
+  def self.name = "??"
+
+  def call(args, _data) = args.find { |v| !v.nil? }
+end

data/lib/json_logic/operations/div.rb

@@ -1,7 +1,13 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::Div < JsonLogic::Operation
   def self.name = "/"
 
-  def call((a,b), _data) = (b.to_f == 0 ? nil : a.to_f / b.to_f)
+  def call(args, _data)
+    raise JsonLogic::InvalidArgumentsError.new if args.empty?
+    numbers = args.map(&:to_f)
+    numbers.one? ? (1.0 / numbers.first) : numbers.drop(1).reduce(numbers.first, :/)
+  end
 end

data/lib/json_logic/operations/equal.rb

@@ -2,10 +2,19 @@
 
 using JsonLogic::Semantics
 
-class JsonLogic::Operations::Equal < JsonLogic::Operation
+class JsonLogic::Operations::Equal < 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 unless prev == current
+
+      prev = current
+    end
+    true
   end
 end

data/lib/json_logic/operations/exists.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+using JsonLogic::Semantics
+
+class JsonLogic::Operations::Exists < JsonLogic::Operation
+  def self.name = "exists"
+  def self.values_only? = false
+
+  def call(args, data) = JsonLogic::Tree.new(data).exists?(normalize_path(args, data), split_dots: false)
+
+  private
+
+  def normalize_path(args, data) = args.is_a?(Array) ? Array.wrap(args).map { |part| JsonLogic.apply(part, data) } : JsonLogic.apply(args, data)
+end

data/lib/json_logic/operations/filter.rb

@@ -6,10 +6,18 @@ class JsonLogic::Operations::Filter < JsonLogic::EnumerableOperation
   def self.name = "filter"
 
   def call(args, data)
-    items, rule_applied_to_each_item = resolve_items_and_per_item_rule(args, data)
+    raise JsonLogic::InvalidArgumentsError.new if args.is_a?(Array) && args.size >= 2 && args[1].nil?
+    raise JsonLogic::InvalidArgumentsError.new unless args.is_a?(Array) && args.size >= 2
+    raise JsonLogic::InvalidArgumentsError.new if args[0].nil?
 
-    items.filter do |item|
-      !!JsonLogic.apply(rule_applied_to_each_item, item)
+    items_rule, rule = args
+    items = Array(JsonLogic.apply(items_rule, data))
+
+    return [] if rule.nil?
+
+    items.each_with_index.each_with_object([]) do |(item, index), filtered|
+      value = JsonLogic.apply(rule, JsonLogic::Scope.new(item, data, index))
+      filtered << item if value.to_bool
     end
   end
 end

data/lib/json_logic/operations/gt.rb

@@ -2,11 +2,19 @@
 
 using JsonLogic::Semantics
 
-class JsonLogic::Operations::GT < JsonLogic::Operation
+class JsonLogic::Operations::GT < JsonLogic::LazyOperation
   def self.name = ">"
 
-  def call(values, _data)
-    return values[0] > values[1] if values.size == 2
-    values.each_cons(2).all? { |a,b| a > b }
+  def call(args, data)
+    raise JsonLogic::InvalidArgumentsError.new unless args.is_a?(Array) && args.size >= 2
+
+    previous = JsonLogic.apply(args.first, data)
+    args.drop(1).all? do |rule|
+      current = JsonLogic.apply(rule, data)
+      next false unless previous > current
+
+      previous = current
+      true
+    end
   end
 end

data/lib/json_logic/operations/gte.rb

@@ -2,11 +2,19 @@
 
 using JsonLogic::Semantics
 
-class JsonLogic::Operations::GTE < JsonLogic::Operation
+class JsonLogic::Operations::GTE < JsonLogic::LazyOperation
   def self.name = ">="
 
-  def call(values, _data)
-    return values[0] >= values[1] if values.size == 2
-    values.each_cons(2).all? { |a,b| a >= b }
+  def call(args, data)
+    raise JsonLogic::InvalidArgumentsError.new unless args.is_a?(Array) && args.size >= 2
+
+    previous = JsonLogic.apply(args.first, data)
+    args.drop(1).all? do |rule|
+      current = JsonLogic.apply(rule, data)
+      next false unless previous >= current
+
+      previous = current
+      true
+    end
   end
 end

data/lib/json_logic/operations/if.rb

@@ -6,6 +6,8 @@ class JsonLogic::Operations::If < JsonLogic::LazyOperation
   def self.name = "if"
 
   def call(args, data)
+    raise JsonLogic::InvalidArgumentsError.new unless args.is_a?(Array)
+
     i = 0
     while i < args.size - 1
       return JsonLogic.apply(args[i + 1], data) if !!(JsonLogic.apply(args[i], data))

data/lib/json_logic/operations/in.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::In < JsonLogic::Operation
   def self.name = "in"
 

data/lib/json_logic/operations/lt.rb

@@ -2,11 +2,17 @@
 
 using JsonLogic::Semantics
 
-class JsonLogic::Operations::LT < JsonLogic::Operation
+class JsonLogic::Operations::LT < JsonLogic::LazyOperation
   def self.name = "<"
 
-  def call(values, _data)
-    return values[0] < values[1] if values.size == 2
-    values.each_cons(2).all? { |a,b| a < b }
+  def call(args, data)
+    raise JsonLogic::InvalidArgumentsError.new unless args.is_a?(Array) && args.size >= 2
+
+    args.drop(1).reduce(JsonLogic.apply(args.first, data)) do |previous, rule|
+      current = JsonLogic.apply(rule, data)
+      return false unless previous < current
+      current
+    end
+    true
   end
 end

data/lib/json_logic/operations/lte.rb

@@ -2,11 +2,19 @@
 
 using JsonLogic::Semantics
 
-class JsonLogic::Operations::LTE < JsonLogic::Operation
+class JsonLogic::Operations::LTE < JsonLogic::LazyOperation
   def self.name = "<="
 
-  def call(values, _data)
-    return values[0] <= values[1] if values.size == 2
-    values.each_cons(2).all? { |a,b| a <= b }
+  def call(args, data)
+    raise JsonLogic::InvalidArgumentsError.new unless args.is_a?(Array) && args.size >= 2
+
+    previous = JsonLogic.apply(args.first, data)
+    args.drop(1).all? do |rule|
+      current = JsonLogic.apply(rule, data)
+      next false unless previous <= current
+
+      previous = current
+      true
+    end
   end
 end

data/lib/json_logic/operations/map.rb

@@ -1,10 +1,22 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::Map < JsonLogic::EnumerableOperation
   def self.name = "map"
 
   def call(args, data)
-    items, rule_applied_to_each_item = resolve_items_and_per_item_rule(args, data)
-    items.map { |item| JsonLogic.apply(rule_applied_to_each_item, item) }
+    raise JsonLogic::InvalidArgumentsError.new if args.is_a?(Array) && args.size >= 2 && args[1].nil?
+    raise JsonLogic::InvalidArgumentsError.new unless args.is_a?(Array) && args.size >= 2
+    raise JsonLogic::InvalidArgumentsError.new if args[0].nil?
+
+    items_rule, rule = args
+    items = Array(JsonLogic.apply(items_rule, data))
+
+    return [] if rule.nil?
+
+    items.each_with_index.map do |item, index|
+      JsonLogic.apply(rule, JsonLogic::Scope.new(item, data, index))
+    end
   end
 end

data/lib/json_logic/operations/max.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::Max < JsonLogic::Operation
   def self.name = "max"
 
-  def call(values, _data) = values.max
+  def call(args, _data) = args.max
 end

data/lib/json_logic/operations/merge.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::Merge < JsonLogic::Operation
   def self.name = "merge"
-  def call(values, _data)
-    values.flat_map { |v| v.is_a?(Array) ? v : [v] }
-  end
+
+  def call(args, _data) = args.flat_map { |v| v.is_a?(Array) ? v : [v] }
 end

data/lib/json_logic/operations/min.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::Min < JsonLogic::Operation
   def self.name = "min"
 
-  def call(values, _data) = values.min
+  def call(args, _data) = args.min
 end

data/lib/json_logic/operations/missing.rb

@@ -1,33 +1,11 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::Missing < JsonLogic::Operation
   def self.name = "missing"
 
-  def call(values, data)
-    keys =
-      if values.size == 1 && values.first.is_a?(Array)
-        values.first
-      else
-        values
-      end
-
-    keys.select { |k| dig(data, k).nil? }
-  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
+  def call(args, data)
+    Array.wrap(args).select { |key| JsonLogic::Tree.new(data).dig(key).nil? }
   end
 end

data/lib/json_logic/operations/missing_some.rb

@@ -1,28 +1,14 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::MissingSome < JsonLogic::Operation
   def self.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
+    json = JsonLogic::Tree.new(data)
+    keys = Array.wrap(list)
+    missing = keys.select { |key| json.dig(key).nil? }
+    (keys.size - missing.size) >= min_ok ? [] : missing
   end
 end

data/lib/json_logic/operations/mod.rb

@@ -1,7 +1,15 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::Mod < JsonLogic::Operation
   def self.name = "%"
 
-  def call((a,b), _data) = a.to_f % b.to_f
+  def call(args, _data)
+    raise JsonLogic::InvalidArgumentsError.new if args.size < 2
+    numbers = args.map(&:to_f)
+    numbers.drop(1).reduce(numbers.first) do |result, divisor|
+      result - divisor * (result / divisor).truncate
+    end
+  end
 end

data/lib/json_logic/operations/mul.rb

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

data/lib/json_logic/operations/none.rb

@@ -5,10 +5,9 @@ using JsonLogic::Semantics
 class JsonLogic::Operations::None < JsonLogic::EnumerableOperation
   def self.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.apply(rule_applied_to_each_item, item))
-    end
+  protected
+
+  def call_with_values(values)
+    values.none? { |value| !!value }
   end
 end

data/lib/json_logic/operations/not_equal.rb

@@ -2,10 +2,19 @@
 
 using JsonLogic::Semantics
 
-class JsonLogic::Operations::NotEqual < JsonLogic::Operation
+class JsonLogic::Operations::NotEqual < 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 prev == current
+
+      prev = current
+    end
+    true
   end
 end

data/lib/json_logic/operations/or.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
 using JsonLogic::Semantics
+
 class JsonLogic::Operations::Or < JsonLogic::LazyOperation
   def self.name = "or"
 
   def call(args, data)
+    raise JsonLogic::InvalidArgumentsError.new unless args.is_a?(Array)
+    return false if args.empty?
+
     args.each do |a|
       v = JsonLogic.apply(a, data)
       return v if !!v
     end
 
-    args.empty? ? nil : JsonLogic.apply(args.last, data)
+    JsonLogic.apply(args.last, data)
   end
 end

data/lib/json_logic/operations/preserve.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+using JsonLogic::Semantics
+
+class JsonLogic::Operations::Preserve < JsonLogic::LazyOperation
+  def self.name = "preserve"
+
+  def call(args, _data) = args.is_a?(Array) ? args : [args]
+end

data/lib/json_logic/operations/reduce.rb

@@ -1,18 +1,34 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::Reduce < JsonLogic::EnumerableOperation
   def self.name = "reduce"
 
   def call(args, data)
-    rule_that_returns_items, step_rule_applied_per_item, rule_that_returns_initial_accumulator = args
+    raise JsonLogic::InvalidArgumentsError.new unless args.is_a?(Array) && args.size >= 2
+
+    rule_that_returns_items = args[0]
+    step_rule_applied_per_item = args[1]
+    rule_that_returns_initial_accumulator = args[2]
+    raise JsonLogic::InvalidArgumentsError.new if step_rule_applied_per_item.nil?
 
-    items = Array(JsonLogic.apply(rule_that_returns_items, data))
-    acc   = JsonLogic.apply(rule_that_returns_initial_accumulator, data)
+    items_value = JsonLogic.apply(rule_that_returns_items, data)
+    items = Array(items_value)
+    acc = rule_that_returns_initial_accumulator.nil? ? nil : JsonLogic.apply(rule_that_returns_initial_accumulator, data)
 
-    items.reduce(acc) do |memo, item|
+    items.each_with_index.reduce(acc) do |memo, (item, idx)|
+      base_data = data.is_a?(Hash) ? data : {}
       JsonLogic.apply(
         step_rule_applied_per_item,
-        (data || {}).merge("" => item, "current" => item, "accumulator" => memo)
+        base_data.merge(
+          "" => item,
+          "current" => item,
+          "accumulator" => memo,
+          "index" => idx,
+          "__parent__" => data,
+          "__scope__" => true
+        )
       )
     end
   end

data/lib/json_logic/operations/some.rb

@@ -1,16 +1,13 @@
-# frozen_string_literal: tru
+# frozen_string_literal: true
 
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::Some < JsonLogic::EnumerableOperation
   def self.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?
+  protected
 
-    items.any? do |item|
-      !!JsonLogic.apply(rule_applied_to_each_item, item)
-    end
+  def call_with_values(values)
+    !values.empty? && values.any? { |value| !!value }
   end
 end

data/lib/json_logic/operations/strict_equal.rb

@@ -1,9 +1,32 @@
 # frozen_string_literal: true
 
-class JsonLogic::Operations::StrictEqual < JsonLogic::Operation
+using JsonLogic::Semantics
+
+class JsonLogic::Operations::StrictEqual < 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 unless 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