json-logic-rb 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc614e1da0fa7f6a40304c0e988508dc71f67b2f65ded67e3ecdbf5be6b4c2ce
-  data.tar.gz: 2e80d861339668970a908e3ffbc6f3ea7562daa51850ce9ce90a1eb35b6ca598
+  metadata.gz: 975d191c041cd7afd3e3ab977d01944e00693ec7320e6418ae312d71afa67d7f
+  data.tar.gz: 9b871c8f3b53fbc5cf3e2dbd180a556e5815940c536da6e2c248bf8b66c9be8d
 SHA512:
-  metadata.gz: b28f05aeb82f7163634d49b7a1eec0e3988b68bd6981111f8ee94de43fc000293730740c116dcb3d757500e58c22672ef1b913199b4d1a901fd50c18fee0963f
-  data.tar.gz: f724dda9f6f0237144fac1255c9b0b20a848decb6981d6a3c19606375a5611c8367bed214e987ecb88b38c9cdaed1e73478ff17052a055b4b0249dfd1ff76bf4
+  metadata.gz: eef9bc4ce561c092cc5bd7885b9f69051e4aa0712dd15e93c92f4dd32c177570472a401e7bdce65565cee4ee8b80e3ebc3afaa46a0fab91cb1f730c83f0e1a83
+  data.tar.gz: fce35e13727e2d30e827c787c5543eb13005c38a59e44abcb8a340b486d1c814d4367d297dc20826b845dd7da98c193b2fa1bf0a521d6aa70bff2847da51eb6c

data/README.md

@@ -55,7 +55,7 @@ There are **two types of operations** in this implementation: Default Operations
 
 ### 1. Default Operations
 
-For **Default Operations**, the engine **evaluates all arguments first** and then calls the operator with the **resulting Ruby values**.  
+For **Default Operations**, the engine **evaluates all arguments first** and then calls the operator with the **resulting Ruby values**.
 This matches the reference behavior for arithmetic, comparisons, string operations, and other pure operations that do not control evaluation order.
 
 **Groups and references:**
@@ -70,16 +70,16 @@ Some operations must control **whether** and **when** their arguments are evalua
 
 **Groups and references:**
 
-- **Branching / boolean control** — `if`, `?:`, `and`, `or`, `var`  
+- **Branching / boolean control** — `if`, `?:`, `and`, `or`, `var`
   [Logic & boolean operations](https://jsonlogic.com/operations.html#logic-and-boolean-operations) • [Truthiness](https://jsonlogic.com/truthy.html)
 
-- **Enumerable operators** — `map`, `filter`, `reduce`, `all`, `none`, `some`  
+- **Enumerable operators** — `map`, `filter`, `reduce`, `all`, `none`, `some`
   [Array operations](https://jsonlogic.com/operations.html#array-operations)
 
 **How enumerable per-item evaluation works:**
 
-1. The first argument is a rule that returns the list of items — evaluated **once** to a Ruby array.  
-2. The second argument is the per-item rule — evaluated **for each item** with that item as the **current root**.  
+1. The first argument is a rule that returns the list of items — evaluated **once** to a Ruby array.
+2. The second argument is the per-item rule — evaluated **for each item** with that item as the **current root**.
 3. For `reduce`, the current item is also available as `"current"`, and the running total as `"accumulator"`.
 
 
@@ -131,7 +131,7 @@ Below is a list that mirrors the sections on [jsonlogic.com/operations.html](htt
 |  `var`  | ✅ |
 |  `missing`  | ✅ |
 |  `missing_some`  | ✅ |
-|[Logic and Boolean Operations](https://jsonlogic.com/operations.html#logic-and-boolean-operations]) 
+|[Logic and Boolean Operations](https://jsonlogic.com/operations.html#logic-and-boolean-operations])
 |  `if`  | ✅ |
 |  `==`  | ✅ |
 |  `===`  | ✅ |
@@ -171,16 +171,43 @@ Below is a list that mirrors the sections on [jsonlogic.com/operations.html](htt
 
 Need a custom operation? It’s straightforward.
 
-### 1) Pick the operation type
+### Quick — register a Proc or Lambda
+
+Register little anonymous functions, by passing a Proc or Lambda.
+
+```ruby
+JsonLogic.add_operation("times2") { |(value), _| value.to_i * 2 }
+```
+
+Once the function added, you can use it in your logic.
+
+```ruby
+JsonLogic.apply({ "times2" => [21] })
+# => 42
+```
+
+Is useful for rapid prototyping with minimal boilerplate;
+Later you can “promote” it into a full class or use additional features.
+
+
+### 1) Pick the Operation type
 Choose one of:
 - **Default**
 ```ruby
 class JsonLogic::Operations::StartsWith < JsonLogic::Operation; end
 ```
+For anonymous functions:
+```ruby
+JsonLogic.add_operation("starts_with", lazy: false) do; end
+```
 - **Lazy**
 ```ruby
 class JsonLogic::Operations::StartsWith < JsonLogic::LazyOperation; end
 ```
+For anonymous functions:
+```ruby
+JsonLogic.add_operation("starts_with", lazy: true) do; end
+```
 
 See [§How](#how) for details.
 
@@ -197,17 +224,17 @@ See [§JsonLogic Semantic](#jsonlogic-semantic) for details.
 ### 3) Create an Operation and provide a machine name
 
 Operation methods use a consistent call shape.
-  
+
 - The first parameter is the **array of operator arguments**.
 - The second is the current **data**.
 
-  
+
 
 Thanks to Ruby’s destructuring, you can unpack the argument array right in the method signature.
 
 ```ruby
 class JsonLogic::Operations::StartsWith < JsonLogic::Operation
-  def self.op_name = "starts_with"
+  def self.name = "starts_with"
   def call((str, prefix), _data)
     # str, prefix are ALREADY evaluated to Ruby values
     str.to_s.start_with?(prefix.to_s)
@@ -227,45 +254,11 @@ After registration, use it in rules:
 { "starts_with": [ { "var": "email" }, "admin@" ] }
 ```
 
-### Alternative — register a Proc/Lambda
 
-The public API is class‑oriented, but **technically** you can express an Operations as a `Proc`/`Lambda` and register it through a little anonymous functions.
-
-DSL to register callables:
-
-```ruby
-module JsonLogic
-  module DSL
-    def self.register_proc(name, lazy: false, &block)
-      base = lazy ? JsonLogic::LazyOperation : JsonLogic::Operation
-      klass = Class.new(base) do
-        define_singleton_method(:op_name) { name.to_s }
-        define_method(:call) { |args, data| block.call(args, data) }
-      end
-      JsonLogic::Engine.default.registry.register(klass)
-      klass
-    end
-  end
-end
-```
-
-  
-
-Is useful for rapid prototyping with minimal boilerplate;
-
-  
-
-```ruby
-JsonLogic::DSL.register_proc("starts_with") do |(str, prefix), _data|
-  str.to_s.start_with?(prefix.to_s)
-end
-```
-
-Later you can “promote” the it into a full class.
 
 ## JsonLogic Semantic
 
-All supported Operations follow JsonLogic semantics. 
+All supported Operations follow JsonLogic semantics.
 
 ### Comparisons
 As JsonLogic primary developed in JavaScript it inherits JavaScript's type coercion in build-in Operations. JsonLogic (JS‑style) comparisons coerce types; Ruby does not.
@@ -293,7 +286,7 @@ using JsonLogic::Semantics
 
 ### Truthiness
 
-JsonLogic’s truthiness differs from Ruby’s (see <https://jsonlogic.com/truthy.html>).  
+JsonLogic’s truthiness differs from Ruby’s (see <https://jsonlogic.com/truthy.html>).
 In Ruby, only `false` and `nil` are falsey. In JsonLogic empty strings and empty arrays are also falsey.
 
 **In Ruby:**
@@ -318,18 +311,18 @@ truthy?([])
 
 Optional: quick self-test
 
-  
+
 
 ```bash
 ruby test/selftest.rb
 ```
 
-  
+
 Official test suite
 
 1. Fetch the official suite
 
-  
+
 
 ```bash
 mkdir -p spec/tmp

data/lib/json_logic/operation.rb

@@ -4,7 +4,7 @@ module JsonLogic
   class Operation
     include Semantics
 
-    def self.op_name = nil
+    def self.name = nil
 
     def self.values_only? = true
 

data/lib/json_logic/operations/add.rb

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

data/lib/json_logic/operations/all.rb

@@ -3,7 +3,7 @@
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::All < JsonLogic::EnumerableOperation
-  def self.op_name = "all"
+  def self.name = "all"
 
   def call(args, data)
     items, rule_applied_to_each_item = resolve_items_and_per_item_rule(args, data)

data/lib/json_logic/operations/and.rb

@@ -3,7 +3,7 @@
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::And < JsonLogic::LazyOperation
-  def self.op_name = "and"
+  def self.name = "and"
 
   def call(args, data)
     last = nil

data/lib/json_logic/operations/bool_cast.rb

@@ -2,7 +2,7 @@
 
 using JsonLogic::Semantics
 class JsonLogic::Operations::BoolCast < JsonLogic::Operation
-  def self.op_name = "!!"
+  def self.name = "!!"
 
   def call((a), _data)
     !!a

data/lib/json_logic/operations/cat.rb

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

data/lib/json_logic/operations/div.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class JsonLogic::Operations::Div < JsonLogic::Operation
-  def self.op_name = "/"
+  def self.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

@@ -3,7 +3,7 @@
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::Equal < JsonLogic::Operation
-  def self.op_name = "=="
+  def self.name = "=="
 
   def call((a,b), _data)
     a == b

data/lib/json_logic/operations/filter.rb

@@ -3,7 +3,7 @@
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::Filter < JsonLogic::EnumerableOperation
-  def self.op_name = "filter"
+  def self.name = "filter"
 
   def call(args, data)
     items, rule_applied_to_each_item = resolve_items_and_per_item_rule(args, data)

data/lib/json_logic/operations/gt.rb

@@ -3,6 +3,6 @@
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::GT < JsonLogic::Operation
-  def self.op_name = ">"
+  def self.name = ">"
   def call((a,b), _data) = a > b
 end

data/lib/json_logic/operations/gte.rb

@@ -3,7 +3,7 @@
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::GTE < JsonLogic::Operation
-  def self.op_name = ">="
+  def self.name = ">="
 
   def call((a,b), _data)
     a >= b

data/lib/json_logic/operations/if.rb

@@ -3,7 +3,7 @@
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::If < JsonLogic::LazyOperation
-  def self.op_name = "if"
+  def self.name = "if"
 
   def call(args, data)
     i = 0

data/lib/json_logic/operations/in.rb

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

data/lib/json_logic/operations/lt.rb

@@ -3,7 +3,7 @@
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::LT < JsonLogic::Operation
-  def self.op_name = "<"
+  def self.name = "<"
 
   def call(values, _data)
     return values[0] < values[1] if values.size == 2

data/lib/json_logic/operations/lte.rb

@@ -3,7 +3,7 @@
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::LTE < JsonLogic::Operation
-  def self.op_name = "<="
+  def self.name = "<="
 
   def call(values, _data)
     return values[0] <= values[1] if values.size == 2

data/lib/json_logic/operations/map.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class JsonLogic::Operations::Map < JsonLogic::EnumerableOperation
-  def self.op_name = "map"
+  def self.name = "map"
 
   def call(args, data)
     items, rule_applied_to_each_item = resolve_items_and_per_item_rule(args, data)

data/lib/json_logic/operations/max.rb

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

data/lib/json_logic/operations/merge.rb

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

data/lib/json_logic/operations/min.rb

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

data/lib/json_logic/operations/missing.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class JsonLogic::Operations::Missing < JsonLogic::Operation
-  def self.op_name = "missing"
+  def self.name = "missing"
 
   def call(values, data)
     keys =

data/lib/json_logic/operations/missing_some.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class JsonLogic::Operations::MissingSome < JsonLogic::Operation
-  def self.op_name = "missing_some"
+  def self.name = "missing_some"
 
   def call((min_ok, list), data)
     arr = list.is_a?(Array) ? list : Array(list)

data/lib/json_logic/operations/mod.rb

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

data/lib/json_logic/operations/mul.rb

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

data/lib/json_logic/operations/none.rb

@@ -3,7 +3,7 @@
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::None < JsonLogic::EnumerableOperation
-  def self.op_name = "none"
+  def self.name = "none"
 
   def call(args, data)
     items, rule_applied_to_each_item = resolve_items_and_per_item_rule(args, data)

data/lib/json_logic/operations/not.rb

@@ -3,7 +3,7 @@
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::Not < JsonLogic::Operation
-  def self.op_name = "!";
+  def self.name = "!";
 
   def call((a), _data) = !a
 end

data/lib/json_logic/operations/not_equal.rb

@@ -3,7 +3,7 @@
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::NotEqual < JsonLogic::Operation
-  def self.op_name = "!="
+  def self.name = "!="
 
   def call((a,b), _data)
     !(a == b)

data/lib/json_logic/operations/or.rb

@@ -2,7 +2,7 @@
 
 using JsonLogic::Semantics
 class JsonLogic::Operations::Or < JsonLogic::LazyOperation
-  def self.op_name = "or"
+  def self.name = "or"
 
   def call(args, data)
     args.each do |a|

data/lib/json_logic/operations/reduce.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class JsonLogic::Operations::Reduce < JsonLogic::EnumerableOperation
-  def self.op_name = "reduce"
+  def self.name = "reduce"
 
   def call(args, data)
     rule_that_returns_items, step_rule_applied_per_item, rule_that_returns_initial_accumulator = args

data/lib/json_logic/operations/some.rb

@@ -3,7 +3,7 @@
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::Some < JsonLogic::EnumerableOperation
-  def self.op_name = "some"
+  def self.name = "some"
 
   def call(args, data)
     items, rule_applied_to_each_item = resolve_items_and_per_item_rule(args, data)

data/lib/json_logic/operations/strict_equal.rb

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

data/lib/json_logic/operations/strict_not_equal.rb

@@ -3,7 +3,7 @@
 using JsonLogic::Semantics
 
 class JsonLogic::Operations::StrictNotEqual < JsonLogic::Operation
-  def self.op_name = "!=="
+  def self.name = "!=="
 
   def call((a,b), _data)
     !(a === b)

data/lib/json_logic/operations/sub.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 class JsonLogic::Operations::Sub < JsonLogic::Operation
-  def self.op_name = "-"
+  def self.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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class JsonLogic::Operations::Substr < JsonLogic::Operation
-  def self.op_name = "substr"
+  def self.name = "substr"
 
   def call(values, _data)
     s, i, len = values

data/lib/json_logic/operations/ternary.rb

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

data/lib/json_logic/operations/var.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class JsonLogic::Operations::Var < JsonLogic::Operation
-  def self.op_name = "var";
+  def self.name = "var";
   def self.values_only? = false
 
   def call((path_rule, fallback_rule), data)

data/lib/json_logic/registry.rb

@@ -7,7 +7,7 @@ module JsonLogic
     end
 
     def register(op_class)
-      name = op_class.op_name or raise ArgumentError, 'op_name missing'
+      name = op_class.name or raise ArgumentError, 'name missing'
       @map[name.to_s] = op_class
       self
     end

data/lib/json_logic/semantics.rb

@@ -86,7 +86,7 @@ module JsonLogic
       end
     end
 
-    [String, Integer, Float].each do |klass|
+    [String, Integer, Float, NilClass, Array, TrueClass, FalseClass].each do |klass|
       refine klass do
         def ==(other) = JsonLogic::Semantics.eq(self, other)
         def >(other)  = (c = JsonLogic::Semantics.cmp(self, other)) && c == 1
@@ -95,11 +95,5 @@ module JsonLogic
         def <=(other) = (c = JsonLogic::Semantics.cmp(self, other)) && (c == -1 || c == 0)
       end
     end
-
-    [Array, TrueClass, FalseClass, NilClass].each do |klass|
-      refine klass do
-        def ==(other) = JsonLogic::Semantics.eq(self, other)
-      end
-    end
   end
 end

data/lib/json_logic/version.rb

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

data/lib/json_logic.rb

@@ -14,10 +14,10 @@ module JsonLogic
 end
 
 
-# Load operation classes (each file defines one class with .op_name)
+# Load operation classes (each file defines one class with .name)
 Dir[File.join(__dir__, 'json_logic', 'operations', '*.rb')].sort.each { |f| require f }
 
-# Auto-register all operation classes with .op_name
+# Auto-register all operation classes with .name
 module JsonLogic
   module Loader
     module_function
@@ -25,7 +25,7 @@ module JsonLogic
     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?
+        next unless klass.respond_to?(:name) && klass.name && !klass.name.to_s.empty?
 
         registry.register(klass)
       end
@@ -36,6 +36,16 @@ module JsonLogic
     def apply(rule, data = nil)
       Engine.default.evaluate(rule, data)
     end
+
+    def add_operation(name, lazy: false, &block)
+      base = lazy ? JsonLogic::LazyOperation : JsonLogic::Operation
+      klass = Class.new(base) do
+        define_singleton_method(:name) { name.to_s }
+        define_method(:call) { |args, data| block.call(args, data) }
+      end
+      JsonLogic::Engine.default.registry.register(klass)
+      klass
+    end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-logic-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Tavrel Kate