json-logic-rb 0.1.0.beta2 → 0.1.1.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 353191c500d952bd851cd63744323aabee9df0ed7ba838496902097e37741ded
-  data.tar.gz: a38434d883bffd18579ead8ef04bb0a75ccfae121b441d4270233dd8451ade00
+  metadata.gz: 4d4064f94160ac9151244253f9a265932a0d30c43288523a73ef9bfcabb97b3b
+  data.tar.gz: e49615ccae718c4f8c87f5289e4d4e0c079a9bd516fd0e15399c978995d1599e
 SHA512:
-  metadata.gz: a80d3d73a45fccb17750f75ca1875c8e85897c4b5e81ecbabeb6e961f78e0eeb0fb69fb3cf3f9da2ff8bb70f53685b1a80a554b5daa718f4740654e6d3ef9310
-  data.tar.gz: b79782b7923300af9ac3f24a816f91e29c5b4126d511f0fcbd9f1bb8eda1b859ca796aece57520e401d776fbfee7111f48c1778262de87b3b60d6baaf24dc17c
+  metadata.gz: c73281072de2de418a28e3104b5e41fa084e57f8a2c4f2c4cd92bb2d0571d0cde87ffd36a86c7eefee03f690e916eb875fc1bf1800ab40faa9eba371afdc1230
+  data.tar.gz: 0a7759d9d56afca69ccc8d7dbd7e623007750288c29ad048719f64f202d124ad8e106545edb99b73489d4f6488df6989394e1bf330bf7e792d0a749d605d089e

data/README.md

@@ -21,7 +21,7 @@ Ruby implementation of [JsonLogic](https://jsonlogic.com/) — simple and extens
   - [Miscellaneous](#miscellaneous)
 - [Extending (add your own operator)](#extending-add-your-own-operator)
 - [Public Interface](#public-interface)
-- [Compliance & tests](#compliance--tests)
+- [Compliance & tests](#compliance-and-tests)
 - [Security](#security)
 - [License](#license)
 - [Contributing](#contributing)
@@ -107,7 +107,7 @@ The operator then evaluates only the sub-rules it actually needs.
 
 **Examples**
 ```ruby
-`# filter: keep numbers >= 2
+# filter: keep numbers >= 2
 JsonLogic.apply(
   { "filter" => [ { "var" => "ints" }, { ">=" => [ { "var" => "" }, 2 ] } ] },
   { "ints" => [1,2,3] }
@@ -282,7 +282,7 @@ engine.registry.register(JsonLogic::Operations::StartsWith)
 
 ---
 
-## Compliance  & tests
+## Compliance and tests
 Optional: quick self-test
 
 ```bash
@@ -313,3 +313,9 @@ Expected output
 - Rules are **data**, not code; no Ruby eval.
 - When evaluating untrusted rules, consider adding a timeout  and error handling at the call site.
 - Custom operations should be **pure** (no IO, no network, no shell).
+
+
+## Authors
+
+- [Valeriya Petrova](https://github.com/piatrova-valeriya1999)
+- [Tavrel Kate](https://github.com/tavrelkate)

data/lib/json_logic/operation.rb

@@ -2,6 +2,8 @@
 
 module JsonLogic
   class Operation
+    include Semantics
+
     def self.op_name = nil
 
     def self.values_only? = true

data/lib/json_logic/operations/add.rb

@@ -2,5 +2,8 @@
 
 class JsonLogic::Operations::Add < JsonLogic::Operation
   def self.op_name = "+"
-  def call(values, _data) = values.map!(&:to_f).sum
+
+  def call(values, _data)
+    values.map!(&:to_f).sum
+  end
 end

data/lib/json_logic/operations/all.rb

@@ -8,9 +8,7 @@ class JsonLogic::Operations::All < JsonLogic::EnumerableOperation
     return false if items.empty?
 
     items.all? do |item|
-      JsonLogic::Semantics.truthy?(
-        JsonLogic.apply(rule_applied_to_each_item, item)
-      )
+      truthy?(JsonLogic.apply(rule_applied_to_each_item, item))
     end
   end
 end

data/lib/json_logic/operations/and.rb

@@ -7,7 +7,7 @@ class JsonLogic::Operations::And < JsonLogic::LazyOperation
     last = nil
     args.each do |a|
       last = JsonLogic.apply(a, data)
-      return last unless JsonLogic::Semantics.truthy?(last)
+      return last unless truthy?(last)
     end
     last
   end

data/lib/json_logic/operations/bool_cast.rb

@@ -4,6 +4,6 @@ class JsonLogic::Operations::BoolCast < JsonLogic::Operation
   def self.op_name = "!!"
 
   def call((a), _data)
-    JsonLogic::Semantics.truthy?(a)
+    truthy?(a)
   end
 end

data/lib/json_logic/operations/cat.rb

@@ -2,5 +2,6 @@
 
 class JsonLogic::Operations::Cat < JsonLogic::Operation
   def self.op_name = "cat"
+
   def call(values, _data) = values.map!(&:to_s).join
 end

data/lib/json_logic/operations/div.rb

@@ -2,5 +2,6 @@
 
 class JsonLogic::Operations::Div < JsonLogic::Operation
   def self.op_name = "/"
+
   def call((a,b), _data) = (b.to_f == 0 ? nil : a.to_f / b.to_f)
 end

data/lib/json_logic/operations/equal.rb

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

data/lib/json_logic/operations/filter.rb

@@ -7,9 +7,7 @@ class JsonLogic::Operations::Filter < JsonLogic::EnumerableOperation
     items, rule_applied_to_each_item = resolve_items_and_per_item_rule(args, data)
 
     items.filter do |item|
-      JsonLogic::Semantics.truthy?(
-        JsonLogic.apply(rule_applied_to_each_item, item)
-      )
+      truthy?(JsonLogic.apply(rule_applied_to_each_item, item))
     end
   end
 end

data/lib/json_logic/operations/gt.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::GT < JsonLogic::Operation
   def self.op_name = ">"
-  def call((a,b), _data) = JsonLogic::Semantics.to_number(a) > JsonLogic::Semantics.to_number(b)
+  def call((a,b), _data) = a > b
 end

data/lib/json_logic/operations/gte.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::GTE < JsonLogic::Operation
   def self.op_name = ">="
-  def call((a,b), _data) = JsonLogic::Semantics.to_number(a) >= JsonLogic::Semantics.to_number(b)
+
+  def call((a,b), _data)
+    a >= b
+  end
 end

data/lib/json_logic/operations/if.rb

@@ -6,7 +6,7 @@ class JsonLogic::Operations::If < JsonLogic::LazyOperation
   def call(args, data)
     i = 0
     while i < args.size - 1
-      return JsonLogic.apply(args[i + 1], data) if JsonLogic::Semantics.truthy?(JsonLogic.apply(args[i], data))
+      return JsonLogic.apply(args[i + 1], data) if truthy?(JsonLogic.apply(args[i], data))
       i += 2
     end
     return JsonLogic.apply(args[-1], data) if args.size.odd?

data/lib/json_logic/operations/{in_op.rb → in.rb}

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-class JsonLogic::Operations::InOp < JsonLogic::Operation
+class JsonLogic::Operations::In < JsonLogic::Operation
   def self.op_name = "in"
+
   def call((a,b), _data) = (b.respond_to?(:include?) && b.include?(a))
 end

data/lib/json_logic/operations/lt.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::LT < JsonLogic::Operation
   def self.op_name = "<"
+
   def call(values, _data)
-    nums = values.map { |v| JsonLogic::Semantics.to_number(v) }
-    return nums[0] < nums[1] if nums.size == 2
-    nums.each_cons(2).all? { |a,b| a < b }
+    return values[0] < values[1] if values.size == 2
+    values.each_cons(2).all? { |a,b| a < b }
   end
 end

data/lib/json_logic/operations/lte.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::LTE < JsonLogic::Operation
   def self.op_name = "<="
+
   def call(values, _data)
-    nums = values.map { |v| JsonLogic::Semantics.to_number(v) }
-    return nums[0] <= nums[1] if nums.size == 2
-    nums.each_cons(2).all? { |a,b| a <= b }
+    return values[0] <= values[1] if values.size == 2
+    values.each_cons(2).all? { |a,b| a <= b }
   end
 end

data/lib/json_logic/operations/max.rb

@@ -2,5 +2,6 @@
 
 class JsonLogic::Operations::Max < JsonLogic::Operation
   def self.op_name = "max"
-  def call(values, _data) = values.max_by { |v| JsonLogic::Semantics.to_number(v) }
+
+  def call(values, _data) = values.max
 end

data/lib/json_logic/operations/min.rb

@@ -2,5 +2,6 @@
 
 class JsonLogic::Operations::Min < JsonLogic::Operation
   def self.op_name = "min"
-  def call(values, _data) = values.min_by { |v| JsonLogic::Semantics.to_number(v) }
+
+  def call(values, _data) = values.min
 end

data/lib/json_logic/operations/missing_some.rb

@@ -10,6 +10,7 @@ class JsonLogic::Operations::MissingSome < JsonLogic::Operation
   end
 
   private
+
   def dig(obj, path)
     return nil if obj.nil?
     cur = obj

data/lib/json_logic/operations/mod.rb

@@ -2,5 +2,6 @@
 
 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/none.rb

@@ -6,9 +6,7 @@ class JsonLogic::Operations::None < JsonLogic::EnumerableOperation
   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)
-      )
+      truthy?(JsonLogic.apply(rule_applied_to_each_item, item))
     end
   end
 end

data/lib/json_logic/operations/not.rb

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

data/lib/json_logic/operations/not_equal.rb

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

data/lib/json_logic/operations/or.rb

@@ -5,8 +5,9 @@ class JsonLogic::Operations::Or < JsonLogic::LazyOperation
   def call(args, data)
     args.each do |a|
       v = JsonLogic.apply(a, data)
-      return v if JsonLogic::Semantics.truthy?(v)
+      return v if truthy?(v)
     end
+
     args.empty? ? nil : JsonLogic.apply(args.last, data)
   end
 end

data/lib/json_logic/operations/reduce.rb

@@ -14,6 +14,6 @@ class JsonLogic::Operations::Reduce < JsonLogic::EnumerableOperation
         step_rule_applied_per_item,
         (data || {}).merge("" => item, "current" => item, "accumulator" => memo)
       )
-    end
+    endgem build
   end
 end

data/lib/json_logic/operations/some.rb

@@ -8,9 +8,7 @@ class JsonLogic::Operations::Some < JsonLogic::EnumerableOperation
     return false if items.empty?
 
     items.any? do |item|
-      JsonLogic::Semantics.truthy?(
-        JsonLogic.apply(rule_applied_to_each_item, item)
-      )
+      truthy?(JsonLogic.apply(rule_applied_to_each_item, item))
     end
   end
 end

data/lib/json_logic/operations/strict_equal.rb

@@ -2,5 +2,8 @@
 
 class JsonLogic::Operations::StrictEqual < JsonLogic::Operation
   def self.op_name = "==="
-  def call((a,b), _data) = JsonLogic::Semantics.strict_equal(a,b)
+  
+  def call((a,b), _data) 
+    a === b
+  end
 end

data/lib/json_logic/operations/strict_not_equal.rb

@@ -2,5 +2,8 @@
 
 class JsonLogic::Operations::StrictNotEqual < JsonLogic::Operation
   def self.op_name = "!=="
-  def call((a,b), _data) = !JsonLogic::Semantics.strict_equal(a,b)
+
+  def call((a,b), _data)
+    !(a === b)
+  end
 end

data/lib/json_logic/operations/ternary.rb

@@ -4,7 +4,7 @@ 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))
+    if truthy?(JsonLogic.apply(cond_rule, data))
       JsonLogic.apply(then_rule, data)
     else
       JsonLogic.apply(else_rule, data)

data/lib/json_logic/operations/var.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 class JsonLogic::Operations::Var < JsonLogic::Operation
-  def self.op_name = "var"; def self.values_only? = false
+  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 == ""
@@ -10,6 +12,7 @@ class JsonLogic::Operations::Var < JsonLogic::Operation
     return nil if fallback_rule.nil?
     JsonLogic.apply(fallback_rule, data)
   end
+
   def dig(obj, path)
     return nil if obj.nil?
     cur = obj

data/lib/json_logic/semantics.rb

@@ -2,8 +2,6 @@
 
 module JsonLogic
   module Semantics
-    NUMERIC_RE = /\A[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?\z/.freeze
-
     module_function
 
     def truthy?(v)
@@ -11,42 +9,82 @@ module JsonLogic
       when nil then false
       when TrueClass, FalseClass then v
       when Numeric then !v.zero?
-      when String then !v.empty?
-      when Array  then !v.empty?
+      when String, Array then !v.empty?
       else true
       end
     end
 
-    def falsy?(v) = !truthy?(v)
-
-    def to_number(v)
+    def num(v)
       case v
-      when Integer then v
-      when Numeric then v.to_f
+      when Numeric    then v.to_f
+      when TrueClass  then 1.0
+      when FalseClass then 0.0
+      when NilClass   then 0.0
+      when Array      then num(v.join(','))
       when String
         s = v.strip
-        return nil unless NUMERIC_RE.match?(s)
-        s =~ /[.eE]/ ? s.to_f : s.to_i
+        return 0.0 if s.empty?
+        Float(s) rescue Float::NAN
       else
-        nil
+        Float::NAN
+      end
+    end
+
+    def eq(a, b)
+      if a.class == b.class
+        return false if a.is_a?(Numeric) && (a.to_f.nan? || b.to_f.nan?)
+        return a.is_a?(Numeric) ? (a.to_f == b.to_f) : a.eql?(b)
+      end
+
+      if a == true || a == false || b == true || b == false
+        na = num(a); nb = num(b)
+        return false if na.nan? || nb.nan?
+        return na == nb
       end
+
+      if (a.is_a?(String) && b.is_a?(Numeric)) || (a.is_a?(Numeric) && b.is_a?(String))
+        na = num(a); nb = num(b)
+        return false if na.nan? || nb.nan?
+        return na == nb
+      end
+
+      false
     end
 
-    def strict_equal(a,b)
-      if a.is_a?(Numeric) && b.is_a?(Numeric)
-        a.to_f == b.to_f
+    def cmp(a, b)
+      if a.is_a?(String) && b.is_a?(String)
+        a <=> b
       else
-        a.class == b.class && a == b
+        x = num(a); y = num(b)
+        return nil if x.nan? || y.nan?
+        x <=> y
       end
     end
 
-    def loose_equal(a, b)
-      if (a.is_a?(Numeric) || a.is_a?(String)) && (b.is_a?(Numeric) || b.is_a?(String))
-        na = to_number(a)
-        nb = to_number(b)
-        return na == nb unless na.nil? || nb.nil?
+    [String, Integer, TrueClass, FalseClass, NilClass, Array].each do |klass|
+      refine klass do
+        def ==(other) = JsonLogic::Semantics.eq(self, other)
+
+        def >(other)
+          c = JsonLogic::Semantics.cmp(self, other)
+          c && c == 1
+        end
+
+        def >=(other)
+          c = JsonLogic::Semantics.cmp(self, other)
+          c && (c == 1 || c == 0)
+        end
+
+        def <(other)
+          c = JsonLogic::Semantics.cmp(self, other)
+          c && c == -1
+        end
+
+        def <=(other)
+          c = JsonLogic::Semantics.cmp(self, other)
+          c && (c == -1 || c == 0)
+        end
       end
-      a == b
     end
   end
 end

data/lib/json_logic/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json-logic-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta2
+  version: 0.1.1.beta1
 platform: ruby
 authors:
 - Tavrel Kate
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-06 00:00:00.000000000 Z
+date: 2025-10-30 00:00:00.000000000 Z
 dependencies: []
 description: Ruby implementation of JsonLogic. JsonLogic rules are JSON trees. The
   engine walks that tree and returns a Ruby value. Ships with a compliance runner
@@ -36,7 +36,7 @@ files:
 - lib/json_logic/operations/gt.rb
 - lib/json_logic/operations/gte.rb
 - lib/json_logic/operations/if.rb
-- lib/json_logic/operations/in_op.rb
+- lib/json_logic/operations/in.rb
 - lib/json_logic/operations/lt.rb
 - lib/json_logic/operations/lte.rb
 - lib/json_logic/operations/map.rb
@@ -63,7 +63,6 @@ files:
 - lib/json_logic/semantics.rb
 - lib/json_logic/version.rb
 - script/compliance.rb
-- spec/tmp/tests.js
 - spec/tmp/tests.json
 - test/selftest.rb
 homepage: https://github.com/tavrelkate/json-logic-rb