shiny_json_logic 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b8a8110c84c6c3c200990803fee38794b6eca329633637a30f4a7f4c06eee95
-  data.tar.gz: 714e59c4620f1d3af97f026185d6a1e2131c7b2d3f6c6093a23334edf32b47b9
+  metadata.gz: a9900ca19c7b287666c48cd69a5343a876f2c4d9c49e1ff224ae7c1b56cdf99b
+  data.tar.gz: eb6909a5a85affc348ddf9d0ed9b5395d384a34bb924aa410da40e5951168538
 SHA512:
-  metadata.gz: d0147aaeda5d79d78786840aa872172c7369f14c5cb6281de4662cef2c9afbf9b299d13262a59244a451738e53c632cffa57dfd749b0256f239d970b9e4711da
-  data.tar.gz: 6e70bebb46e6fed627138f8fc84d91cc4d2db44fb88df32ceea8f65a6f09233907c7c1383950bf6c8baf42ab18ad21f7fc83842f8222f476d77a1853a7bdfa81
+  metadata.gz: 45ec24f6e4a8bc0e8c45285fa8e11eabd06c8161957e4798ce3f7ae19d843aec07f64bb901a1c726c0594d8990f5fbad858ccad126fce9a0a937de4431d2245e
+  data.tar.gz: 6e398b31cb5f27592158082bffa8f113baa436cafa498b5c7f9c2d20c01d522857d6eb63195cfa6e8acc1669af68081d839461fcf0462fc2e2ee6b1f44c2cced

data/.github/workflows/compat.yml

@@ -0,0 +1,74 @@
+name: Compatibility
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  compat:
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Ruby (latest)
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ruby
+          bundler-cache: true
+      - name: Run test suite (non-blocking)
+        continue-on-error: true
+        run: |
+          set +e
+          bin/test.sh
+          echo "exit_code=$?" >> $GITHUB_ENV
+          set -e
+
+      - name: Generate compatibility badge
+        if: always()
+        run: |
+          PASSED=$(jq -r '.totals.shiny_json_logic.passed' results/ruby.json)
+          TOTAL=$(jq -r '.totals.shiny_json_logic.total' results/ruby.json)
+
+          PCT=$(awk "BEGIN { printf \"%.1f\", ($PASSED/$TOTAL)*100 }")
+
+          COLOR="red"
+          awk "BEGIN { exit !($PCT >= 90) }" && COLOR="yellow"
+          awk "BEGIN { exit !($PCT >= 97) }" && COLOR="green"
+
+          mkdir -p badges
+          cat > badges/compat.json <<EOF
+          {
+            "schemaVersion": 1,
+            "label": "compat",
+            "message": "${PCT}% (${PASSED}/${TOTAL})",
+            "color": "${COLOR}"
+          }
+          EOF
+
+          {
+            echo "## JSONLogic compatibility"
+            echo ""
+            echo "- **${PCT}%** (${PASSED}/${TOTAL})"
+            echo "- exit code (ignored): ${exit_code:-0}"
+          } >> $GITHUB_STEP_SUMMARY
+
+      # Commit automático del badge (solo master)
+      - name: Commit badge
+        if: github.ref == 'refs/heads/master'
+        run: |
+          if git diff --quiet -- badges/compat.json; then
+            echo "No badge change"
+            exit 0
+          fi
+
+          git config user.name "github-actions"
+          git config user.email "github-actions@github.com"
+          git add badges/compat.json
+          git commit -m "chore: update compat badge"
+          git push

data/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.1.7] - 2026-02-01
+### Added
+- Adds support for `try` and `throw` operators.
+- Introduces context mechanism to allow other operations to leverage context data.
+### Changed
+- Refactors internal architecture to support context-aware operations.
+- Returns to recursive approach as it is easier to develop this way
+- If now handles rules calculation lazily
+
+## [0.1.6] - 2026-01-25
+### Added
+- Improve CI support for Ruby 4.0 (no runtime changes).
+- Adds GitHub Actions CI workflow for Ruby 4.0.
+
 ## [0.1.5] - 2026-01-25
 ### Changed
 - Improve RubyGems gem description (no runtime changes).

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    shiny_json_logic (0.1.6)
+    shiny_json_logic (0.1.7)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,14 +1,12 @@
 # ShinyJsonLogic ✨
 
-[![CI](https://github.com/luismoyano/shiny-json-logic-ruby/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/luismoyano/shiny-json-logic-ruby/actions/workflows/ci.yml)
+![Compatibility](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/luismoyano/shiny-json-logic-ruby/master/badges/compat.json)
 [![Gem Version](https://badge.fury.io/rb/shiny_json_logic.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/shiny_json_logic)
 ![Ruby](https://img.shields.io/badge/ruby-%3E%3D%202.7-brightgreen)
 
-> **A boring, correct, and production-ready JSON Logic implementation for Ruby. ✨** 
+> **A boring, correct and production-ready JSON Logic implementation for Ruby. ✨** 
 
-**ShinyJsonLogic** is a **pure Ruby**, **zero-dependency** implementation of the JSON Logic specification.
-
-We exist because the original Ruby implementation has been neglected for years.
+**ShinyJsonLogic** is a **pure Ruby**, **zero-dependency** JSON Logic implementation, designed to offer a reliable and well-tested engine for Ruby applications.
 
 This gem focuses on predictable behavior, strict spec alignment, high compatibility and long-term maintainability.
 
@@ -16,12 +14,11 @@ This gem focuses on predictable behavior, strict spec alignment, high compatibil
 
 ## Why ShinyJsonLogic?
 
-- ✅ **Zero runtime dependencies** (stdlib-only). Just plug & play!
-- ✅ **Ruby 2.7+ compatible, one of the lowest among other Ruby implementations**
-- ✅ **Actively maintained**
-- ✅ **High JSON Logic spec coverage**
-- ✅ **Iterative approach:** Stop worrying about long statements breaking your app.
-- ⭐ **Only Ruby implementation supporting the new standard operations up to date.**
+- 🧩 **Zero runtime dependencies** (stdlib-only). Just plug & play!
+- 🕰️ **Ruby 2.7+ compatible**, one of the lowest minimum versions supported in the Ruby ecosystem.
+- 🔧 **Actively maintained** and continuously improved.
+- 📊 **Highest JSON Logic compatibility in the Ruby ecosystem**, as measured against the official test suites.
+- ⭐ **Only Ruby implementation supporting the latest standard operators** (`val`, `exists`, `??`, `try`, `throw`)
 
 If you want JSON Logic to *just work* in Ruby, this is the safe default.
 
@@ -49,7 +46,7 @@ gem install shiny_json_logic
 
 and require it in your project:
 
-```rubyruby
+```ruby
 require "shiny_json_logic"
 ```
 
@@ -102,7 +99,7 @@ Our goal is **full JSON Logic coverage**.
 Currently implemented operators include:
 
 ### Logic
-`if`, `and`, `or`, `!`, `!!`
+`if`, `and`, `or`, `!`, `!!`, `?:`, `try`✨, `throw`✨
 
 ### Comparison
 `==`, `===`, `!=`, `!==`, `>`, `>=`, `<`, `<=`
@@ -123,7 +120,7 @@ Currently implemented operators include:
 `map, reduce, filter, some, all, none`
 
 📌 **Note:**  
-`val`, `exists` and `??` are **only supported by ShinyJsonLogic** at the moment.
+`val`, `exists`, `??`, `try` and `throw` are **only supported by ShinyJsonLogic** among Ruby implementations.
 
 (See `lib/shiny_json_logic/operations` for the authoritative list.)
 
@@ -131,9 +128,8 @@ Currently implemented operators include:
 
 ## Compatibility
 
-ShinyJsonLogic is designed to track the official JSON Logic specification as closely as possible.
-
-A compatibility PR against the JSON Logic test tables is currently in progress and will be linked here once merged.
+Compatibility is measured automatically against the official JSONLogic test suites from `json-logic/compat-tables`.
+See `badges/compat.json` for the exact numbers behind the badge.
 
 ---
 
@@ -155,7 +151,12 @@ bin/console
 Install locally:
 
 ```bash
-bundle exec rake install
+bundle install
+```
+How to run the compatibility tests:
+
+```bash
+bin/test.sh
 ```
 
 ---

data/badges/compat.json

@@ -0,0 +1,6 @@
+{
+  "schemaVersion": 1,
+  "label": "compat",
+  "message": "76.4% (860/1126)",
+  "color": "red"
+}

data/bin/test.sh

@@ -0,0 +1,77 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT_DIR"
+
+# Config
+COMPAT_REF="${COMPAT_REF:-main}"
+COMPAT_REPO="${COMPAT_REPO:-json-logic/compat-tables}"
+TMP_DIR="${TMP_DIR:-$ROOT_DIR/tmp}"
+SUITES_DIR="$TMP_DIR/compat-suites"
+
+# Helpers
+log() { printf "\n\033[1m%s\033[0m\n" "$*"; }
+
+log "Installing gems"
+bundle install
+
+# ---- Compatibility suites (optional but recommended) ----
+# Download ONLY the suites folder from the compat-tables repo archive.
+# This avoids a full git clone and works everywhere as long as curl+tar exist.
+
+log "Fetching compat suites from GitHub: $COMPAT_REPO@$COMPAT_REF"
+
+rm -rf "$SUITES_DIR"
+mkdir -p "$SUITES_DIR"
+
+ARCHIVE_URL="https://codeload.github.com/${COMPAT_REPO}/tar.gz/${COMPAT_REF}"
+
+# Extract only: compat-tables-<ref>/suites -> tmp/compat-suites
+# Different refs create different top-level folder names; we strip the first path component.
+curl -fsSL "$ARCHIVE_URL" \
+  | tar -xz \
+      --strip-components=2 \
+      -C "$SUITES_DIR" \
+      "compat-tables-${COMPAT_REF}/suites" 2>/dev/null \
+
+log "Compat suites ready at: $SUITES_DIR"
+
+log "Running compatibility suite"
+COMPAT_OUT="$TMP_DIR/compat-rspec.out"
+
+set +e
+COMPAT_SUITES_DIR="$SUITES_DIR" bundle exec rspec spec/compatibility_spec.rb | tee "$COMPAT_OUT"
+COMPAT_EXIT=${PIPESTATUS[0]}
+set -e
+
+# Parse totals from RSpec summary
+TOTAL=$(ruby -e '
+  s = STDIN.read
+  m = s.match(/(\d+)\s+examples?,\s+(\d+)\s+failures?/)
+  abort "Could not parse RSpec summary" unless m
+  puts m[1]
+' < "$COMPAT_OUT")
+
+FAILURES=$(ruby -e '
+  s = STDIN.read
+  m = s.match(/(\d+)\s+examples?,\s+(\d+)\s+failures?/)
+  abort "Could not parse RSpec summary" unless m
+  puts m[2]
+' < "$COMPAT_OUT")
+
+PASSED=$((TOTAL - FAILURES))
+
+mkdir -p results
+cat > results/ruby.json <<EOF
+{
+  "totals": {
+    "shiny_json_logic": {
+      "passed": $PASSED,
+      "total": $TOTAL
+    }
+  }
+}
+EOF
+
+echo "Compat: ${PASSED}/${TOTAL} (failures: ${FAILURES}, exit: ${COMPAT_EXIT})"

data/lib/core_ext/array.rb

@@ -1,5 +1,3 @@
-require 'backport_dig' if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
-
 class Array
   def self.wrap(object)
     return [] if object.nil?

data/lib/shiny_json_logic/engine.rb

@@ -1,123 +1,58 @@
 require "core_ext/array"
 require "core_ext/hash"
-Dir[File.join(__dir__, "operations/**/*.rb")].each do |file|
-  require file
-end
+require "shiny_json_logic/operator_solver"
 
 module ShinyJsonLogic
   class Engine
+    attr_reader :errors
+
     def initialize(rule, data = {})
       @rule = rule
-      @data = data
+      @data = data || {}
+      @errors = []
     end
 
-    def call
-      stack   = [[rule, data, :enter]]
-      results = []
-
-      while stack.any?
-        node, ctx, state = stack.pop
-
-        if state == :exit
-          # Already evaluated children, we solve
-          if node.is_a?(Hash)
-            op, raw_args = node.to_a.first
-
-            if collection_solvers.key?(op)
-              results << collection_solvers.fetch(op).new(raw_args, ctx).call
-            else
-              if raw_args.is_a?(Array)
-                argc = raw_args.size
-                args = results.pop(argc)
-                results << solvers.fetch(op).new(args, ctx).call
-              else
-                args = Array.wrap(results.pop)
-                results << solvers.fetch(op).new(args, ctx).call
-              end
-            end
-          elsif node.is_a?(Array)
-            results << results.pop(node.size)
-          end
-
-          next
-        end
-
-        # ENTER phase
-        case node
-        when Hash
-          op, raw_args = node.to_a.first
-
-          stack << [node, ctx, :exit]
-
-          unless collection_solvers.key?(op)
+    def call(rule = self.rule, data = self.data)
+      if rule.is_a?(Hash)
+        operation, raw_args = rule.to_a.first
+        if operations.collection_solvers.key?(operation)
+          solve(operation, raw_args, data)
+        else
+          evaluated_args =
             if raw_args.is_a?(Array)
-              raw_args.reverse_each { |a| stack << [a, ctx, :enter] }
+              raw_args.map { |val| call(val, data) }
             else
-              stack << [raw_args, ctx, :enter]
+              Array.wrap(call(raw_args, data))
             end
-          end
 
-        when Array
-          stack << [node, ctx, :exit]
-          node.reverse_each { |n| stack << [n, ctx, :enter] }
-
-        else
-          results << node
+          solve(operation, evaluated_args, data)
         end
+      elsif rule.is_a?(Array)
+        rule.map { |val| call(val, data) }
+      else
+        rule
       end
-
-      results.last
     end
 
     private
 
-    attr_reader :rule, :data
+    attr_reader :rule
+    attr_accessor :data
+    attr_writer :errors
+
+    def solve(operation, args, initial_data)
+      context = {"rules" => args, "data" => initial_data, "errors" => errors}
+      p operation, context
+      result, data, errors = operations.solvers.fetch(operation).new(context).call.values_at("result", "data", "errors")
+      self.errors = [*self.errors, *errors].uniq
+      self.data.merge data if self.data.is_a?(Hash) && data.is_a?(Hash)
+      p "RESULT AFTER #{operation.upcase}: #{result.inspect}"
 
-    def solvers
-      @@solvers ||= {
-        "var" => Operations::Var,
-        "missing" => Operations::Missing,
-        "missing_some" => Operations::MissingSome,
-        "if" => Operations::If,
-        "==" => Operations::Equal,
-        "===" => Operations::StrictEqual,
-        "!=" => Operations::Different,
-        "!==" => Operations::StrictDifferent,
-        ">" => Operations::Greater,
-        ">=" => Operations::GreaterEqual,
-        "<" => Operations::Smaller,
-        "<=" => Operations::SmallerEqual,
-        "!" => Operations::Not,
-        "or" => Operations::Or,
-        "and" => Operations::And,
-        "?:" => Operations::If,
-        "in" => Operations::Inclusion,
-        "cat" => Operations::Concatenation,
-        "%" => Operations::Modulo,
-        "max" => Operations::Max,
-        "min" => Operations::Min,
-        "+" => Operations::Addition,
-        "*" => Operations::Product,
-        "-" => Operations::Subtraction,
-        "/" => Operations::Division,
-        "substr" => Operations::Substring,
-        "merge" => Operations::Merge,
-        "!!" => Operations::DoubleNot,
-        "val" => Operations::Val,
-        "??" => Operations::Coalesce,
-        "exists" => Operations::Exists,
-      }
+      result
     end
 
-    def collection_solvers
-      @@collection_solvers ||= {
-        "filter" => Operations::Filter,
-        "map" => Operations::Map,
-        "reduce" => Operations::Reduce,
-        "all" => Operations::All,
-        "none" => Operations::None,
-        "some" => Operations::Some,
-      }
+    def operations
+      @operations ||= OperatorSolver.new
     end
   end
 end

data/lib/shiny_json_logic/errors/base.rb

@@ -0,0 +1,20 @@
+require "securerandom"
+
+module ShinyJsonLogic
+  module Errors
+    class Base < StandardError
+      attr_reader :type, :id
+      attr_accessor :panic
+
+      def initialize(type: nil)
+        super(type)
+        @type = type
+        @id = "shiny_error_#{SecureRandom.uuid}"
+      end
+
+      def payload
+        @payload ||= { "type" => type }
+      end
+    end
+  end
+end

data/lib/shiny_json_logic/numericals/with_error_handling.rb

@@ -0,0 +1,17 @@
+module ShinyJsonLogic
+  module Numericals
+    module WithErrorHandling
+      def safe_arithmetic(&block)
+        result = yield
+        result.tap do |res|
+          if res.to_f.nan? || res == Float::INFINITY || res == -Float::INFINITY
+            self.data["type"] = "NaN"
+            error = ShinyJsonLogic::Errors::Base.new(type: "NaN")
+            errors.push error
+            return error.id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shiny_json_logic/operations/addition.rb

@@ -3,7 +3,9 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Addition < Base
-      def call
+      protected
+
+      def run
         rules.map(&:to_f).reduce(:+)
       end
     end

data/lib/shiny_json_logic/operations/all.rb

@@ -6,10 +6,6 @@ module ShinyJsonLogic
     class All < Iterable::Base
       private
 
-      def on_each(_item)
-        ShinyJsonLogic.apply(filter, data)
-      end
-
       def on_after(results)
         return false if results.empty?
 

data/lib/shiny_json_logic/operations/and.rb

@@ -4,7 +4,9 @@ require "shiny_json_logic/truthy"
 module ShinyJsonLogic
   module Operations
     class And < Base
-      def call
+      protected
+
+      def run
         rules.reduce { |a, b| Truthy.call(a) ? b : a }
       end
     end

data/lib/shiny_json_logic/operations/base.rb

@@ -3,19 +3,31 @@ require "shiny_json_logic/truthy"
 module ShinyJsonLogic
   module Operations
     class Base
-      def initialize(rules, data)
-        @rules = rules
-        @data = data
+      def initialize(context)
+        @context = context
+        @rules, @data, @errors = @context.values_at("rules", "data", "errors")
       end
 
       def call
-        raise "Not implemented"
+        deliver run
+      rescue StandardError => e # TODO: refine error handling
+        error_type = e.is_a?(Errors::Base) ? e.type : e.class.to_s
+
+        Errors::Base.new(type: error_type)
       end
 
       protected
 
-      attr_reader :rules
-      attr_accessor :data
+      attr_reader :rules, :context
+      attr_accessor :data, :errors
+
+      def run
+        raise NotImplementedError
+      end
+
+      def deliver(result = nil)
+        {"result" => result, "data" => self.data, "errors" => self.errors}
+      end
     end
   end
 end

data/lib/shiny_json_logic/operations/coalesce.rb

@@ -3,7 +3,9 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Coalesce < Base
-      def call
+      protected
+
+      def run
         rules.compact.first
       end
     end

data/lib/shiny_json_logic/operations/concatenation.rb

@@ -3,7 +3,9 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Concatenation < Base
-      def call
+      protected
+
+      def run
         return rules.map(&:to_s).join if rules.is_a?(Array)
 
         rules

data/lib/shiny_json_logic/operations/different.rb

@@ -5,7 +5,8 @@ module ShinyJsonLogic
   module Operations
     class Different < Base
       def call
-        !Operations::Equal.new(rules, data).call
+        ctx = Operations::Equal.new(context).call
+        {"result" => !ctx["result"], "data" => ctx["data"], "errors" => ctx["errors"]}
       end
     end
   end

data/lib/shiny_json_logic/operations/division.rb

@@ -1,10 +1,16 @@
 require "shiny_json_logic/operations/base"
+require "shiny_json_logic/numericals/with_error_handling"
 
 module ShinyJsonLogic
   module Operations
     class Division < Base
-      def call
-        rules.map(&:to_f).reduce(:/)
+      include Numericals::WithErrorHandling
+      protected
+
+      def run
+        safe_arithmetic do
+          rules.map(&:to_f).reduce(:/)
+        end
       end
     end
   end

data/lib/shiny_json_logic/operations/double_not.rb

@@ -4,7 +4,9 @@ require "shiny_json_logic/truthy"
 module ShinyJsonLogic
   module Operations
     class DoubleNot < Base
-      def call
+      protected
+
+      def run
         !!Truthy.call(rules.first)
       end
     end

data/lib/shiny_json_logic/operations/equal.rb

@@ -3,7 +3,9 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Equal < Base
-      def call
+      protected
+
+      def run
         rules.map(&:to_s).all? { |v| v == rules[0].to_s }
       end
     end

data/lib/shiny_json_logic/operations/exists.rb

@@ -3,7 +3,9 @@ require "shiny_json_logic/operations/base"
 module ShinyJsonLogic
   module Operations
     class Exists < Base
-      def call
+      protected
+
+      def run
         current = data
 
         Array.wrap(rules).each do |segment|
@@ -13,7 +15,7 @@ module ShinyJsonLogic
         end
 
         true
-      rescue
+      rescue StandardError
         false
       end
     end