json-logic-rb 0.2.0.beta1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe25d64cef43ddb57ad9f94bec45b401ce7ee19b29757108336644342f75f8e1
-  data.tar.gz: 21e8ef8421a8768c8be32795c855cc52ec4a4afed79a5875399372417fa06da9
+  metadata.gz: 810c50b59976cf832b8171f84696315690a47d99a894f65e7430b6a62f5effa0
+  data.tar.gz: d398558a21b6b194da078ba175f03349ddc5f8f17a51d939e0b554f267a9e15d
 SHA512:
-  metadata.gz: e228a5ed37724d97e54c87e726f772e5f5a749a114a8b02a332bf9131da06c83fedaf0f5d059bd61c94c1c0be73c34ab9fc1cd9d6c6408c958159d951c3a36c9
-  data.tar.gz: 805c23fe8af646123f4c5535111d14576ebbf6c1aeeaf6b01247bbc0dd92399e9584ddd869b4522b6a5734c601e701e7736b27b628ccc2cc576f7a26b211fe84
+  metadata.gz: a4fb7f21bfebbd7f852f62be1dc7acf4a9047aac1af3405b5d37e3c64fdc9b08b7c30b85a3168e1b64c716aefcf2526a6003b20ba5494ce2b8c55f1c5b01d225
+  data.tar.gz: 604c4a8adbe4b06fd130e0fcc07443a79899d2f1f777bf6b82da815fb9277fef5bff7c2c596329ce62042ece12d1258f0cb61fc997a43bf532546efb7881f618

data/README.md

@@ -1,43 +1,30 @@
-
-
-
-
-
-
-
-
-
-
-
+[![jsonlogic core][src-core]][core-tests] [![jsonlogic community][src-community]][community-suites] [![compliance 100%][badge-compliance]][ci-main] [![Build Status][badge-buildkite]][ci-main] [![rubygems][badge-rubygems]][rubygems] [![license][badge-license]][license]
 
 # json-logic-rb
 
-Ruby implementation of [JsonLogic](https://jsonlogic.com/) — elegant and extensible. Full compliance with both core and community-extended specifications.
-
-[![jsonlogic core][src-core]](https://jsonlogic.com/tests.json) [![jsonlogic community][src-community]](https://github.com/json-logic/compat-tables/tree/main/suites) [![compliance 100%](https://img.shields.io/badge/compliance-100%25-brightgreen)](https://github.com/tavrelkate/json-logic-rb/actions/workflows/compliance.yml?query=branch%3Amain) <a href="https://rubygems.org/gems/json-logic-rb"><img alt="rubygems" src="https://img.shields.io/gem/v/json-logic-rb"></a> <a href="LICENSE"><img alt="license" src="https://img.shields.io/badge/license-MIT-informational"></a>
+Ruby implementation of [JsonLogic](https://jsonlogic.com/). Pure and extensible. Full compliance with both core and community-extended specifications.
 
 ## Table of Contents
 - [What](#what)
 - [Install](#install)
 - [Quick start](#quick-start)
-- [How](#how)
-  - [1. Default Operations](#1-default-operations)
-  - [2. Lazy Operations](#2-lazy-operations)
-- [Why laziness matters?](#why-laziness-matters)
-- [Compliance and tests](#compliance-and-tests)
-  - [Script](#script)
-- [Supported Operations (Built‑in)](#supported-operations-built-in)
+- [Compliance](#compliance)
+- [Supported Operations (Built-in)](#supported-operations-built-in)
 - [Adding Operations](#adding-operations)
   - [Enable JsonLogic Semantics (optional)](#enable-jsonlogic-semantics-optional)
   - [Parameters](#parameters)
-  - [Proc / Lambda](#proc--lambda)
+  - [Proc and Lambda](#proc-and-lambda)
   - [Class](#class)
+- [Laziness](#laziness)
+  - [1. Default Operations](#1-default-operations)
+  - [2. Lazy Operations](#2-lazy-operations)
+  - [Why laziness matters?](#why-laziness-matters)
 - [JsonLogic Semantic](#jsonlogic-semantic)
   - [Comparisons](#comparisons)
   - [Truthiness](#truthiness)
 - [Security](#security)
 - [License](#license)
-- [Authors](#authors)
+- [Maintainers](#maintainers)
 
 ---
 
@@ -84,106 +71,22 @@ JsonLogic.apply(rule, data)
 # => 42
 ```
 
-## How
-
-There are two types of operations: [Default Operations](#1-default-operations)  and [Lazy Operations](#2-lazy-operations).
-
-### 1. Default Operations
-
-For **Default Operations**, the it 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:**
-
-- [Numeric operations](https://jsonlogic.com/operations.html#numeric-operations)
-- [String operations](https://jsonlogic.com/operations.html#string-operations)
-- [Array operations](https://jsonlogic.com/operations.html#array-operations) — simple transform like `merge`.
-
-### 2. Lazy Operations
-
-Some operations must control whether and when their arguments are evaluated. They implement branching, short-circuiting, or “apply a rule per item” semantics. For these **Lazy Operations**, the engine passes raw sub-rules and data. The operator then evaluates only the sub-rules it actually needs.
-
-**Groups and references:**
-
-- [Logic and Boolean Operations](https://jsonlogic.com/operations.html#logic-and-boolean-operations) — short-circuit/branching like `or`.
-- [Comparison operations](https://jsonlogic.com/operations.html#logic-and-boolean-operations) — equality/ordering like `==`.
-- [Array operations](https://jsonlogic.com/operations.html#array-operations) — enumerable evaluation like `map`.
-
-
-**Example #1**
-
-```ruby
-# filter: keep numbers >= 2
-JsonLogic.apply(
-  { "filter" => [ { "var" => "ints" }, { ">=" => [ { "var" => "" }, 2 ] } ] },
-  { "ints" => [1,2,3] }
-)
-# => [2, 3]
-```
-
-### Why laziness matters?
 
-Lazy operations prevent evaluation of branches you do not need.
-
-If hypothetically division by zero raises an error, lazy control would avoid it.
-```ruby
-JsonLogic.apply({ "or" => [1, { "/" => [1, 0] }] })
-# => 1
-```
-
-> In this gem division returns nil on divide‑by‑zero, but this example show why lazy evaluation is required by the spec: branching and boolean operators must not evaluate unused branches.
 
 
 
+## Compliance
 
-
-
-## Compliance and tests
-
-The JsonLogic specification provides  test suites — concrete inputs with expected outputs that validate the implementation of operations. The specification come in two variants:
-- [![jsonlogic core][src-core]](https://jsonlogic.com/tests.json)  — [original JsonLogic website](https://jsonlogic.com/tests.json);
-- [![jsonlogic community][src-community]](https://github.com/json-logic/compat-tables/tree/main/suites) — [extensions built on top of the core](https://github.com/json-logic/compat-tables/tree/main/suites);
+The JsonLogic specification provides test suites — concrete inputs with expected outputs that validate the implementation of operations. The specification comes in two variants:
+- [![jsonlogic core][src-core]](https://jsonlogic.com) – [original JsonLogic website](https://jsonlogic.com/tests.json)
+- [![jsonlogic community][src-community]](https://github.com/json-logic) – [extensions built on top of the core](https://github.com/json-logic/compat-tables/tree/main/suites)
 
  The "extra"  exists because "core" hasn't changed in years — and that’s fine, "core"  is a solid, finished foundation. Think of it as v1, while "extra" is the v2+ evolution as there are no visible plans to change the original.
 
-### Script
-
-Download test suite v1:
 
-```bash
-mkdir -p spec/tmp/v1
-curl -L https://jsonlogic.com/tests.json -o spec/tmp/v1/tests.json
-```
+## Supported Operations (Built-in)
 
-Download test suite v2:
 
-```bash
-mkdir -p spec/tmp/v2
-git clone https://github.com/json-logic/compat-tables.git /tmp/compat-tables
-ruby script/build_tests_json.rb /tmp/compat-tables/suites spec/tmp/v2/tests.json
-```
-
-Run by version:
-
-```bash
-ruby script/compliance.rb -v 1
-ruby script/compliance.rb -v 2
-```
-
-Run by file path:
-
-```bash
-ruby script/compliance.rb -f spec/tmp/v2/tests.json
-```
-
-
-## Supported Operations (Built‑in)
-
-Don’t expect JsonLogic to include every specialized operation. It’s intentionally small and not a programming language. It will never do everything.
-
-You can add custom operations yourself — check out  [§Adding Operations](https://www.google.com/search?q=%23adding-operations)— or consider if the logic can be expressed with what’s already there.
-
-If a feature is simple, lightweight, and universally needed — open an issue or discussion.
 
 
 | Operator | Supported | Source |
@@ -236,19 +139,32 @@ If a feature is simple, lightweight, and universally needed — open an issue or
 | `throw` | ✅ | ![jsonlogic community](https://img.shields.io/badge/jsonlogic--community-extra-0366d6?style=flat-square) |
 | `preserve` | ✅ | ![jsonlogic community](https://img.shields.io/badge/jsonlogic--community-extra-0366d6?style=flat-square) |
 | Docs-only / Not implemented | | |
-| `log` | 🚫 | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `log` | 🚫 | ![jsonlogic docs](https://img.shields.io/badge/jsonlogic-docs-6a737d?style=flat-square) |
 
 
 [src-core]: https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square
 [src-community]: https://img.shields.io/badge/jsonlogic--community-extra-0366d6?style=flat-square
+[badge-compliance]: https://img.shields.io/badge/compliance-100%25-brightgreen
+[badge-buildkite]: https://img.shields.io/github/actions/workflow/status/tavrelkate/json-logic-rb/compliance.yml?branch=main&label=build
+[badge-rubygems]: https://img.shields.io/gem/v/json-logic-rb
+[badge-license]: https://img.shields.io/badge/license-MIT-informational
+[core-tests]: https://jsonlogic.com
+[community-suites]: https://github.com/json-logic
+[ci-main]: https://github.com/tavrelkate/json-logic-rb/actions/workflows/compliance.yml?query=branch%3Amain
+[rubygems]: https://rubygems.org/gems/json-logic-rb
+[license]: LICENSE
+
 
 ## Adding Operations
 
-Need a custom Operation? It’s straightforward. Start small with a Proc or Lambda. If needed – promote it to a Class.
+Don’t expect JsonLogic to include every specialized operation. It’s intentionally small and not a programming language. It will never do everything.
+
+Before you reach for a custom solution, see if you can express your logic using the [§Supported Operations (Built-in)](#supported-operations-built-in). Often, a simple change in perspective is all you need to get the job done with what's already there.
 
+If that doesn't cut it, adding a custom operation is straightforward.  Keep it simple: start with a Proc or a Lambda.  If needed – promote it to a Class.
 
 
-### 	Enable JsonLogic Semantics (optional)
+### Enable JsonLogic Semantics (optional)
 Enable semantics to mirror JsonLogic’s comparison and truthiness in Ruby.
 
 See [§JsonLogic Semantic](#jsonlogic-semantic) for details.
@@ -265,7 +181,7 @@ Operator function use a consistent call shape:
 ->((string, prefix), data) { string.to_s.start_with?(prefix.to_s) }
 ```
 
-### Proc / Lambda
+### Proc and Lambda
 
 Pick the Operation type.
 
@@ -286,7 +202,7 @@ JsonLogic.add_operation("starts_with", lazy: true) do |(string_rule, prefix_rule
 end
 ```
 
-See [§How](https://github.com/tavrelkate/json-logic-rb?tab=readme-ov-file#how) for details.
+See [§Laziness](#laziness) for details.
 
 Use immediately:
 
@@ -329,6 +245,59 @@ JsonLogic.apply({ "starts_with" => [ { "var" => "email" }, "admin@" ] })
 
 
 
+
+## Laziness
+
+There are two types of operations: [Default Operations](#1-default-operations)  and [Lazy Operations](#2-lazy-operations).
+
+### 1. Default Operations
+
+For **Default Operations**, the it 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:**
+
+- [Numeric operations](https://jsonlogic.com/operations.html#numeric-operations)
+- [String operations](https://jsonlogic.com/operations.html#string-operations)
+- [Array operations](https://jsonlogic.com/operations.html#array-operations) — simple transform like `merge`.
+
+### 2. Lazy Operations
+
+Some operations must control whether and when their arguments are evaluated. They implement branching, short-circuiting, or “apply a rule per item” semantics. For these **Lazy Operations**, the engine passes raw sub-rules and data. The operator then evaluates only the sub-rules it actually needs.
+
+**Groups and references:**
+
+- [Logic and Boolean Operations](https://jsonlogic.com/operations.html#logic-and-boolean-operations) — short-circuit/branching like `or`.
+- [Comparison operations](https://jsonlogic.com/operations.html#logic-and-boolean-operations) — equality/ordering like `==`.
+- [Array operations](https://jsonlogic.com/operations.html#array-operations) — enumerable evaluation like `map`.
+
+
+**Example #1**
+
+```ruby
+# filter: keep numbers >= 2
+JsonLogic.apply(
+  { "filter" => [ { "var" => "ints" }, { ">=" => [ { "var" => "" }, 2 ] } ] },
+  { "ints" => [1,2,3] }
+)
+# => [2, 3]
+```
+
+### Why laziness matters?
+
+Lazy operations prevent evaluation of branches you do not need.
+
+If hypothetically division by zero raises an error, lazy control would avoid it.
+```ruby
+JsonLogic.apply({ "or" => [1, { "/" => [1, 0] }] })
+# => 1
+```
+
+> In this gem division returns nil on divide‑by‑zero, but this example show why lazy evaluation is required by the spec: branching and boolean operators must not evaluate unused branches.
+
+
+
+
 ## JsonLogic Semantic
 
 All supported Operations follow JsonLogic semantics.
@@ -391,7 +360,7 @@ using JsonLogic::Semantics
 
 MIT — see [LICENSE](LICENSE).
 
-## Authors
+## Maintainers
 
-- [Valeriya Petrova](https://github.com/piatrova-valeriya1999)
+- [Valeriya Petrova](https://github.com/valeryia-piatrova)
 - [Tavrel Kate](https://github.com/tavrelkate)

data/lib/json_logic/engine.rb

@@ -33,7 +33,12 @@ module JsonLogic
           return rule.transform_values { |value| evaluate(value, data) }
         end
 
-        args = op_class.values_only? ? Array.wrap(evaluate(raw_args, data)) : raw_args
+        if op_class.values_only?
+          evaluated = evaluate(raw_args, data)
+          args = evaluated.is_a?(Array) ? evaluated : [evaluated]
+        else
+          args = raw_args
+        end
         begin
           result = op_class.new.call(args, data)
           raise JsonLogic::NaNError.new if result.is_a?(Float) && (result.nan? || result.infinite?)

data/lib/json_logic/errors/unknown_operator_error.rb

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

data/lib/json_logic/operations/exists.rb

@@ -10,5 +10,5 @@ class JsonLogic::Operations::Exists < JsonLogic::Operation
 
   private
 
-  def normalize_path(args, data) = args.is_a?(Array) ? Array.wrap(args).map { |part| JsonLogic.apply(part, data) } : JsonLogic.apply(args, data)
+  def normalize_path(args, data) = args.is_a?(Array) ? args.as_array.map { |part| JsonLogic.apply(part, data) } : JsonLogic.apply(args, data)
 end

data/lib/json_logic/operations/missing.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+using JsonLogic::Semantics
+
 class JsonLogic::Operations::Missing < JsonLogic::Operation
   def self.name = "missing"
 
   def call(args, data)
-    Array.wrap(args).select { |key| JsonLogic::Tree.new(data).dig(key).nil? }
+    args.as_array.select { |key| JsonLogic::Tree.new(data).dig(key).nil? }
   end
 end

data/lib/json_logic/operations/missing_some.rb

@@ -7,7 +7,7 @@ class JsonLogic::Operations::MissingSome < JsonLogic::Operation
 
   def call((min_ok, list), data)
     json = JsonLogic::Tree.new(data)
-    keys = Array.wrap(list)
+    keys = list.as_array
     missing = keys.select { |key| json.dig(key).nil? }
     (keys.size - missing.size) >= min_ok ? [] : missing
   end

data/lib/json_logic/operations/strict_equal.rb

@@ -11,14 +11,22 @@ class JsonLogic::Operations::StrictEqual < JsonLogic::LazyOperation
     prev = JsonLogic.apply(args.first, data)
     args[1..].each do |arg|
       current = JsonLogic.apply(arg, data)
-      if prev.is_a?(Numeric) && current.is_a?(Numeric)
-        return false unless prev.to_f == current.to_f
-      else
-        return false unless prev.class == current.class && prev == current
-      end
+      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

data/lib/json_logic/operations/strict_not_equal.rb

@@ -11,14 +11,22 @@ class JsonLogic::Operations::StrictNotEqual < JsonLogic::LazyOperation
     prev = JsonLogic.apply(args.first, data)
     args[1..].each do |arg|
       current = JsonLogic.apply(arg, data)
-      if prev.is_a?(Numeric) && current.is_a?(Numeric)
-        return false if prev.to_f == current.to_f
-      else
-        return false if prev.class == current.class && prev == current
-      end
+      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/try.rb

@@ -6,7 +6,7 @@ class JsonLogic::Operations::Try < JsonLogic::LazyOperation
   def self.name = "try"
 
   def call(arguments, data)
-    arguments = Array.wrap(arguments)
+    arguments = arguments.as_array
     raise JsonLogic::InvalidArgumentsError.new if arguments.empty?
 
     state = { data: data, error: nil }

data/lib/json_logic/semantics.rb

@@ -84,6 +84,12 @@ module JsonLogic
       def to_bool
         JsonLogic::Semantics.truthy?(self)
       end
+
+      def as_array = [self]
+    end
+
+    refine Array do
+      def as_array = self
     end
 
     [String, Integer, Float, NilClass, Array, TrueClass, FalseClass].each do |klass|

data/lib/json_logic/version.rb

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

data/lib/json_logic.rb

@@ -6,7 +6,6 @@ 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'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: json-logic-rb
 version: !ruby/object:Gem::Version
-  version: 0.2.0.beta1
+  version: 0.3.0
 platform: ruby
 authors:
 - Tavrel Kate
 bindir: bin
 cert_chain: []
-date: 2026-02-18 00:00:00.000000000 Z
+date: 2026-09-06 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. Full compliance with both core
@@ -25,7 +25,7 @@ files:
 - lib/json_logic/errors/invalid_arguments_error.rb
 - lib/json_logic/errors/logic_error.rb
 - lib/json_logic/errors/nan_error.rb
-- lib/json_logic/ext/array.rb
+- lib/json_logic/errors/unknown_operator_error.rb
 - lib/json_logic/lazy_operation.rb
 - lib/json_logic/operation.rb
 - lib/json_logic/operations/add.rb
@@ -78,11 +78,11 @@ files:
 - spec/tmp/v1/tests.json
 - spec/tmp/v2/tests.json
 - test/selftest.rb
-homepage: https://github.com/tavrelkate/json-logic-rb
+homepage: https://jsonlogic.com
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/tavrelkate/json-logic-rb
+  homepage_uri: https://jsonlogic.com
   source_code_uri: https://github.com/tavrelkate/json-logic-rb
   documentation_uri: https://github.com/tavrelkate/json-logic-rb
   changelog_uri: https://github.com/tavrelkate/json-logic-rb/blob/main/CHANGELOG.md
@@ -102,5 +102,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.2
 specification_version: 4
-summary: Ruby implementation of JsonLogic — elegant and extensible.
+summary: Ruby implementation of JsonLogic. Pure and extensible. Full compliance.
 test_files: []

data/lib/json_logic/ext/array.rb

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