json-logic-rb 0.1.5 → 0.2.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8a44ea9eaa8d259e8122202d3db3608b8e6513f452f7daa0e1b53b96dbb3d09
-  data.tar.gz: 29cc6846d185232738182e1d0e677d852e9efd8446bc31613c563817dac7d221
+  metadata.gz: fe25d64cef43ddb57ad9f94bec45b401ce7ee19b29757108336644342f75f8e1
+  data.tar.gz: 21e8ef8421a8768c8be32795c855cc52ec4a4afed79a5875399372417fa06da9
 SHA512:
-  metadata.gz: 9bf0840e39f08f3e8c4a99a49196cace077ba17e005634df74349a58cf70b92e40e24907149fe00f9fb5b0c634ea0ad1f6deef222c0576b1f9224b3683162a5a
-  data.tar.gz: a96a9d99cb366dd0ff07a974da4dce757aa1836e4abb553c80ea9caadbd28c96be5080063bff5749949b7fdc7b74ecf2feee7bf898093121bedb1a0299b8dfb5
+  metadata.gz: e228a5ed37724d97e54c87e726f772e5f5a749a114a8b02a332bf9131da06c83fedaf0f5d059bd61c94c1c0be73c34ab9fc1cd9d6c6408c958159d951c3a36c9
+  data.tar.gz: 805c23fe8af646123f4c5535111d14576ebbf6c1aeeaf6b01247bbc0dd92399e9584ddd869b4522b6a5734c601e701e7736b27b628ccc2cc576f7a26b211fe84

data/README.md

@@ -1,9 +1,20 @@
 
+
+
+
+
+
+
+
+
+
+
+
 # json-logic-rb
 
-Ruby implementation of [JsonLogic](https://jsonlogic.com/) — simple and extensible. Ships with a compliance runner for the official test suite.
+Ruby implementation of [JsonLogic](https://jsonlogic.com/) — elegant and extensible. Full compliance with both core and community-extended specifications.
 
-<a  href="#"><img  alt="build"  src="https://img.shields.io/github/actions/workflow/status/your-org/json-logic-rb/ci-complience?branch=main">  <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>
+[![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>
 
 ## Table of Contents
 - [What](#what)
@@ -12,10 +23,18 @@ Ruby implementation of [JsonLogic](https://jsonlogic.com/) — simple and extens
 - [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)
 - [Adding Operations](#adding-operations)
+  - [Enable JsonLogic Semantics (optional)](#enable-jsonlogic-semantics-optional)
+  - [Parameters](#parameters)
+  - [Proc / Lambda](#proc--lambda)
+  - [Class](#class)
 - [JsonLogic Semantic](#jsonlogic-semantic)
-- [Compliance and tests](#compliance-and-tests)
+  - [Comparisons](#comparisons)
+  - [Truthiness](#truthiness)
 - [Security](#security)
 - [License](#license)
 - [Authors](#authors)
@@ -27,9 +46,20 @@ JsonLogic rules are JSON trees. The engine walks that tree and returns a Ruby va
 
 ## Install
 
+Download the gem locally
 ```bash
 gem install json-logic-rb
 ```
+If needed – add to your  Gemfile
+
+```ruby
+gem "json-logic-rb"
+```
+
+Then install
+```shell
+bundle install
+```
 
 ## Quick start
 
@@ -45,42 +75,39 @@ JsonLogic.apply(rule)
 With data:
 
 ```ruby
-JsonLogic.apply({ "var" => "user.age" }, { "user" => { "age" => 42 } })
+require 'json_logic'
+
+rule = { "var" => "user.age" }
+data = { "user" => { "age" => 42 } }
+
+JsonLogic.apply(rule, data)
 # => 42
 ```
 
 ## How
 
-There are **two types of operations** in this implementation: Default Operations and Lazy Operations.
+There are two types of operations: [Default Operations](#1-default-operations)  and [Lazy Operations](#2-lazy-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 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 transforms like `merge`, membership `in`.
+- [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 current data. The operator then evaluates only the sub-rules it actually needs.
+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:**
 
-- **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`
-  [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**.
-3. For `reduce`, the current item is also available as `"current"`, and the running total as `"accumulator"`.
+- [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**
@@ -94,168 +121,214 @@ JsonLogic.apply(
 # => [2, 3]
 ```
 
-**Example #2**
-
-```ruby
-# reduce: sum using "current" and "accumulator"
-JsonLogic.apply(
-  { "reduce" => [
-      { "var" => "ints" },
-      { "+" => [ { "var" => "accumulator" }, { "var" => "current" } ] }, 0 ]
-  },
-  { "ints" => [1,2,3,4] }
-)
-# => 10.0
-```
-
 ### Why laziness matters?
 
-Lazy operations **prevent evaluation** of branches you do not need. If division by zero raised an error (hypothetically), lazy control would avoid it:
+Lazy operations prevent evaluation of branches you do not need.
 
+If hypothetically division by zero raises an error, lazy control would avoid it.
 ```ruby
-# "or" short-circuits: 1 is truthy, so the right side is NOT evaluated.
-# If the right side were evaluated eagerly, it would attempt 1/0 (error).
 JsonLogic.apply({ "or" => [1, { "/" => [1, 0] }] })
 # => 1
 ```
 
-> In this gem `/` returns `nil` on divide‑by‑zero, but these examples show **why** lazy evaluation is required by the spec: branching and boolean operators must **not** evaluate unused branches.
+> 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.
 
-## Supported Operations (Built‑in)
 
 
-Below is a list that mirrors the sections on [jsonlogic.com/operations.html](https://jsonlogic.com/operations.html) and shows what this gem (library) implements. From the reference page’s list, everything except `log` is implemented.
-
-| Operator | Supported |
-|---|---:|
-|  `var`  | ✅ |
-|  `missing`  | ✅ |
-|  `missing_some`  | ✅ |
-|[Logic and Boolean Operations](https://jsonlogic.com/operations.html#logic-and-boolean-operations])
-|  `if`  | ✅ |
-|  `==`  | ✅ |
-|  `===`  | ✅ |
-|  `!=`  | ✅ |
-|  `!==`  | ✅ |
-|  `!`  | ✅ |
-|  `!!`  | ✅ |
-|  `or`  | ✅ |
-|  `and`  | ✅ |
-|  `?:`  | ✅ |
-|[Numeric Operations](https://jsonlogic.com/operations.html#numeric-operations)|
-|  `map`  | ✅ |
-|  `reduce`  | ✅ |
-|  `filter`  | ✅ |
-|  `all`  | ✅ |
-|  `none`  | ✅ |
-|  `some`  | ✅ |
-|  `merge`  | ✅ |
-|  `in`  | ✅ |
-|[Array Operations](https://jsonlogic.com/operations.html#array-operations)|
-|  `map`  | ✅ |
-|  `reduce`  | ✅ |
-|  `filter`  | ✅ |
-|  `all`  | ✅ |
-|  `none`  | ✅ |
-|  `some`  | ✅ |
-|  `merge`  | ✅ |
-|  `in`  | ✅ |
-|[String Operations](https://jsonlogic.com/operations.html#string-operations)|
-|  `in`  | ✅ |
-|  `cat`  | ✅ |
-|  `substr`  | ✅ |
-|Miscellaneous|
-|  `log` | 🚫 |
 
-## Adding Operations
 
-Need a custom operation? It’s straightforward.
 
-### Quick — register a Proc or Lambda
+## Compliance and tests
 
-Register little anonymous functions, by passing a Proc or Lambda.
+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);
 
-```ruby
-JsonLogic.add_operation("times2") { |(value), _| value.to_i * 2 }
-```
+ 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.
 
-Once the function added, you can use it in your logic.
+### Script
 
-```ruby
-JsonLogic.apply({ "times2" => [21] })
-# => 42
-```
+Download test suite v1:
 
-Is useful for rapid prototyping with minimal boilerplate;
-Later you can “promote” it into a full class or use additional features.
+```bash
+mkdir -p spec/tmp/v1
+curl -L https://jsonlogic.com/tests.json -o spec/tmp/v1/tests.json
+```
 
+Download test suite v2:
 
-### 1) Pick the Operation type
-Choose one of:
-- **Default**
-```ruby
-class JsonLogic::Operations::StartsWith < JsonLogic::Operation; end
+```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
 ```
-For anonymous functions:
-```ruby
-JsonLogic.add_operation("starts_with", lazy: false) do; end
+
+Run by version:
+
+```bash
+ruby script/compliance.rb -v 1
+ruby script/compliance.rb -v 2
 ```
-- **Lazy**
-```ruby
-class JsonLogic::Operations::StartsWith < JsonLogic::LazyOperation; end
+
+Run by file path:
+
+```bash
+ruby script/compliance.rb -f spec/tmp/v2/tests.json
 ```
-For anonymous functions:
+
+
+## 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 |
+|---|---:|---|
+| [Data / Presence](https://jsonlogic.com/operations.html#accessing-data) | | |
+| `var` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `val` | ✅ | ![jsonlogic community](https://img.shields.io/badge/jsonlogic--community-extra-0366d6?style=flat-square) |
+| `missing` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `missing_some` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `exists` | ✅ | ![jsonlogic community](https://img.shields.io/badge/jsonlogic--community-extra-0366d6?style=flat-square) |
+| [Logic and Boolean Operations](https://jsonlogic.com/operations.html#logic-and-boolean-operations) | | |
+| `if` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `?:` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `and` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `or` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `!` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `!!` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| [Comparison Operations](https://jsonlogic.com/operations.html#logic-and-boolean-operations) | | |
+| `==` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `===` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `!=` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `!==` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `>` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `>=` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `<` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `<=` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| [Numeric Operations](https://jsonlogic.com/operations.html#numeric-operations) | | |
+| `+` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `-` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `*` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `/` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `%` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `min` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `max` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| [Array Operations](https://jsonlogic.com/operations.html#array-operations) | | |
+| `map` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `reduce` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `filter` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `all` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `none` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `some` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `merge` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| [String Operations](https://jsonlogic.com/operations.html#string-operations) | | |
+| `in` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `cat` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| `substr` | ✅ | ![jsonlogic](https://img.shields.io/badge/jsonlogic-core-2ea44f?style=flat-square) |
+| [Community Extensions](https://github.com/json-logic/compat-tables/tree/main/suites) | | |
+| `??` | ✅ | ![jsonlogic community](https://img.shields.io/badge/jsonlogic--community-extra-0366d6?style=flat-square) |
+| `try` | ✅ | ![jsonlogic community](https://img.shields.io/badge/jsonlogic--community-extra-0366d6?style=flat-square) |
+| `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) |
+
+
+[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
+
+## Adding Operations
+
+Need a custom Operation? It’s straightforward. Start small with a Proc or Lambda. If needed – promote it to a Class.
+
+
+
+### 	Enable JsonLogic Semantics (optional)
+Enable semantics to mirror JsonLogic’s comparison and truthiness in Ruby.
+
+See [§JsonLogic Semantic](#jsonlogic-semantic) for details.
+
+
+### Parameters
+
+Operator function use a consistent call shape:
+
+-   First parameter: **array of operator arguments** (you can destructure it).
+
+-   Second parameter: current **data**.
 ```ruby
-JsonLogic.add_operation("starts_with", lazy: true) do; end
+->((string, prefix), data) { string.to_s.start_with?(prefix.to_s) }
 ```
 
-See [§How](#how) for details.
+### Proc / Lambda
+
+Pick the Operation type.
 
-### 2) Enable JsonLogic Semantics (optional)
-Enable semantics to mirror JsonLogic’s comparison/truthiness in Ruby:
+[Default Operation](#1-default-operations) mode passes values.
 
 ```ruby
-using JsonLogic::Semantics
+JsonLogic.add_operation("starts_with") do |(string_value, prefix_value), _data|
+  string_value.to_s.start_with?(prefix_value.to_s)
+end
 ```
+[Lazy Operation](#2-lazy-operations) mode passes raw rules (you evaluate them):
 
+```ruby
+JsonLogic.add_operation("starts_with", lazy: true) do |(string_rule, prefix_rule), data|
+  string_value = JsonLogic.apply(string_rule, data)
+  prefix_value = JsonLogic.apply(prefix_rule, data)
+  string_value.to_s.start_with?(prefix_value.to_s)
+end
+```
 
-See [§JsonLogic Semantic](#jsonlogic-semantic) for details.
+See [§How](https://github.com/tavrelkate/json-logic-rb?tab=readme-ov-file#how) for details.
 
-### 3) Create an Operation and provide a machine name
+Use immediately:
 
-Operation methods use a consistent call shape.
+```ruby
+JsonLogic.apply({ "starts_with" => [ { "var" => "email" }, "admin@" ] })
+```
 
-- The first parameter is the **array of operator arguments**.
-- The second is the current **data**.
 
+### Class
 
+Pick the Operation type. It has the same call shape.
 
-Thanks to Ruby’s destructuring, you can unpack the argument array right in the method signature.
+[Default Operation](#1-default-operations)  – Inherit `JsonLogic::Operation`.
 
 ```ruby
 class JsonLogic::Operations::StartsWith < JsonLogic::Operation
   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)
-  end
+  def call(string_value, prefix_value), _data) = string_value.to_s.start_with?(prefix_value.to_s)
 end
 ```
 
-### 4) Register the new operation
+[Lazy Operation](#2-lazy-operations)  – Inherit `JsonLogic::LazyOperation`.
+
+Register explicitly:
 
 ```ruby
 JsonLogic::Engine.default.registry.register(JsonLogic::Operations::StartsWith)
 ```
 
-After registration, use it in rules:
+Now, Class is ready to use.
 
-```json
-{ "starts_with": [ { "var": "email" }, "admin@" ] }
+```ruby
+JsonLogic.apply({ "starts_with" => [ { "var" => "email" }, "admin@" ] })
 ```
 
 
 
+
+
+
+
+
 ## JsonLogic Semantic
 
 All supported Operations follow JsonLogic semantics.
@@ -281,13 +354,14 @@ As JsonLogic primary developed in JavaScript it inherits JavaScript's type coerc
 ```ruby
 using JsonLogic::Semantics
 
-1 >= "1.0" # => true
+1 >= "1.0"
+# => true
 ```
 
 ### Truthiness
 
-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.
+JsonLogic’s truthiness differs from Ruby’s (see  [Json Logic Website Truthy and Falsy](https://jsonlogic.com/truthy.html)).
+In Ruby, only `false` and `nil` are falsey. In JsonLogic empty strings and empty arrays are falsey too.
 
 **In Ruby:**
 ```ruby
@@ -295,57 +369,23 @@ In Ruby, only `false` and `nil` are falsey. In JsonLogic empty strings and empty
 # => true
 ```
 
-While JsonLogic as was mentioned before has it's own truthiness:
+While JsonLogic as was mentioned before has it's own truthiness.
 
 **In Ruby (with JsonLogic Semantic):**
 
 ```ruby
-include JsonLogic::Semantics
+using JsonLogic::Semantics
 
-truthy?([])
+!![]
 # => false
 ```
 
-
-## Compliance and tests
-
-Optional: quick self-test
-
-
-
-```bash
-ruby test/selftest.rb
-```
-
-
-Official test suite
-
-1. Fetch the official suite
-
-
-
-```bash
-mkdir -p spec/tmp
-curl -fsSL https://jsonlogic.com/tests.json -o spec/tmp/tests.json
-```
-
-2. Run it
-
-```bash
-ruby script/compliance.rb spec/tmp/tests.json
-```
-
-  Expected output
-
-```bash
-# => Compliance: X/X passed
-```
-
 ## Security
 
-- Rules are **data**, not code; no Ruby eval.
-- Operations are **pure** (no IO, no network, no shell).
-- Rules have **no write** access to anything.
+- RULES ARE DATA; NO RUBY EVAL;
+- OPERATIONS ARE PURE; NO IO, NO NETWORK; NO SHELL;
+- RULES HAVE NO WRITE ACCESS TO ANYTHING;
+
 
 ## License
 

data/lib/json_logic/engine.rb

@@ -17,34 +17,35 @@ module JsonLogic
     attr_reader :registry
 
     def evaluate(rule, data = nil)
-      data ||= {}
-
       case rule
-      when Numeric,
-           String,
-           TrueClass,
-           FalseClass,
-           NilClass
+      when Numeric, String, TrueClass, FalseClass, NilClass
         rule
       when Array
         rule.map { |r| evaluate(r, data) }
       when Hash
+        unless rule.one?
+          return rule.transform_values { |value| evaluate(value, data) }
+        end
+
         name, raw_args = rule.first
         op_class = @registry.fetch(name)
-        raise ArgumentError, "unknown operation: #{name}" unless op_class
-
-        args =
-          case raw_args
-          when nil   then []
-          when Array then raw_args
-          else            [raw_args]
-          end
-
-        if op_class.values_only?
-          values = args.map { |a| evaluate(a, data) }
-          op_class.new.call(values, data)
-        else
-          op_class.new.call(args, data)
+        unless op_class
+          return rule.transform_values { |value| evaluate(value, data) }
+        end
+
+        args = op_class.values_only? ? Array.wrap(evaluate(raw_args, data)) : raw_args
+        begin
+          result = op_class.new.call(args, data)
+          raise JsonLogic::NaNError.new if result.is_a?(Float) && (result.nan? || result.infinite?)
+          result
+        rescue JsonLogic::Error
+          raise
+        rescue ArgumentError, IndexError, TypeError, NoMethodError
+          raise JsonLogic::InvalidArgumentsError.new
+        rescue ZeroDivisionError, FloatDomainError
+          raise JsonLogic::NaNError.new
+        rescue StandardError => e
+          raise JsonLogic::Error.new(e.message.to_s)
         end
       else
         rule

data/lib/json_logic/enumerable_operation.rb

@@ -1,9 +1,31 @@
 class JsonLogic::EnumerableOperation < JsonLogic::LazyOperation
-  private
+  def call(args, data)
+    raise JsonLogic::InvalidArgumentsError.new unless args.is_a?(Array) && args.size >= 2
+    raise JsonLogic::InvalidArgumentsError.new if args[0].nil?
 
-  def resolve_items_and_per_item_rule(rules, data)
-    rule_that_returns_items, rule_applied_to_each_item = rules
-    items = Array(JsonLogic.apply(rule_that_returns_items, data))
-    [items, rule_applied_to_each_item]
+    items, rule = extract_items_and_rule(args, data)
+    raise JsonLogic::InvalidArgumentsError.new unless items.is_a?(Array)
+
+    call_with_values(evaluate_values(items, rule, data))
+  end
+
+  protected
+
+  def call_with_values(_values)
+    raise NotImplementedError
+  end
+
+  def extract_items_and_rule(rules, data)
+    items_rule, rule = rules
+    items = JsonLogic.apply(items_rule, data)
+    [items, rule]
+  end
+
+  def evaluate_values(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/errors/error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module JsonLogic
+  class Error < StandardError
+    DEFAULT_MESSAGE = "Error"
+
+    attr_reader :type, :message, :payload
+
+    def initialize(message = nil)
+      @message = message_or_default(message)
+
+      super(@message)
+    end
+
+    def payload
+      { "type" => @message }
+    end
+
+    private
+
+    def message_or_default(message)
+      self.class < JsonLogic::Error || message.empty? ? default_message : message.to_s
+    end
+
+    def default_message
+      self.class::DEFAULT_MESSAGE
+    end
+  end
+end

data/lib/json_logic/errors/invalid_arguments_error.rb

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