json-logic-rb 0.2.0.beta1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe25d64cef43ddb57ad9f94bec45b401ce7ee19b29757108336644342f75f8e1
-  data.tar.gz: 21e8ef8421a8768c8be32795c855cc52ec4a4afed79a5875399372417fa06da9
+  metadata.gz: bf7e4291a1fe0a56b1387ca35f03d239679f4d0c76333a3d0d0f3933efeead0b
+  data.tar.gz: 134bb254ff81c389daa1d9527b9496d17d0417316143586ea8ade75c739f2657
 SHA512:
-  metadata.gz: e228a5ed37724d97e54c87e726f772e5f5a749a114a8b02a332bf9131da06c83fedaf0f5d059bd61c94c1c0be73c34ab9fc1cd9d6c6408c958159d951c3a36c9
-  data.tar.gz: 805c23fe8af646123f4c5535111d14576ebbf6c1aeeaf6b01247bbc0dd92399e9584ddd869b4522b6a5734c601e701e7736b27b628ccc2cc576f7a26b211fe84
+  metadata.gz: 2a98a01a255cdce55c19940171b00fcf652e9735369e6316d747cbfc70108ed42c207d8beca244bf042b47f0a7aa978b962e523fed9662bc2d35970f5476d6b4
+  data.tar.gz: f2a6bedd19099407dbd4398647553cbe9a341926b71b0cdd6c50f99fbe856015ff20a8408087e295c4a459dd13d2c2cdf360810b9af4ceff07e98e102e8012da

data/README.md

@@ -1,37 +1,24 @@
-
-
-
-
-
-
-
-
-
-
-
+[![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>
 
 # 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)
+- [Complience](#complience)
+- [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)
+- [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)
@@ -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:**
+## Complience
 
-- [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 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/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 "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:
+## Supported Operations (Built-in)
 
-```bash
-mkdir -p spec/tmp/v1
-curl -L https://jsonlogic.com/tests.json -o spec/tmp/v1/tests.json
-```
 
-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,23 @@ 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
 
+
 ## 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)](https://www.google.com/search?q=%23supported-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.
@@ -286,7 +193,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 +236,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 +351,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/operations/missing.rb

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

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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-logic-rb
 version: !ruby/object:Gem::Version
-  version: 0.2.0.beta1
+  version: 0.2.0
 platform: ruby
 authors:
 - Tavrel Kate
@@ -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: []