shiny_json_logic 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df28d5d017bd1ab98a68a0a52e4405fea97b552dba04f5994f0f5cdc047b13e6
-  data.tar.gz: f2cae8902b0451e53e1a0e73ec6e4f675de0d8e95f432f64273d8e920faea5cc
+  metadata.gz: a0344634b8f6d210b6968b38d5353c7890df29d927481d23686bc720b8680aab
+  data.tar.gz: 8d7e436d54cf970a720415c9bba2af1ab7fe5677718072b42bd756bbba901300
 SHA512:
-  metadata.gz: 2d92cc98618b3fad9881fd45694b6f8e18b83467bf77904495f9398940a45fefebb93da0617ff2491afd9f53c53769499360dad9fb2d81db3bf88f9393fa0818
-  data.tar.gz: 93694b232429c9dab07352cad06c498ccfc9aa899f51a61046a087c80a5835a4fa6ab8647931b81cc13dfe9ea82f51182ca2fbf5483903f2c5b724246b2e9dd0
+  metadata.gz: dcaf78915b3198bdc3da54b9ca0e12e8118105bcea515cd09e1fc83815d3b2d4c63d715c0849e2b7e6348f36754f7a25d2a50221c5e5cb41fc96a26832b085c7
+  data.tar.gz: a6e3414cdf9db71cc870e15357fd62e726ac1eba25b134424cc882ea84a33b0af45dc391e16aec6c10ccbfd8ec9b201dc0679d8c5b3f9b8dd03305693cf4d21b

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.4] - 2026-01-25
+### Changed
+- Improve RubyGems metadata and gem description (no runtime changes).
+- Improves README md
+
+## [0.1.3]
+### Added
+- Adds Support for `val`, `exists` and `??` operators.
+
+## [0.1.0]
+- Initial release with support for legacy JSON Logic operators.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    shiny_json_logic (0.1.0)
+    shiny_json_logic (0.1.4)
 
 GEM
   remote: https://rubygems.org/
@@ -32,10 +32,10 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.17)
+  bundler
   byebug
   pry
-  rake (~> 10.0)
+  rake
   rspec (~> 3.0)
   shiny_json_logic!
 

data/README.md

@@ -1,12 +1,26 @@
 # ShinyJsonLogic ✨
 
-> Shine bright like a Ruby 💎
+> Shine bright like a Ruby 💎  
+> **A boring, correct, and production-ready JSON Logic implementation for Ruby.**
 
-A **working** JSON Logic implementation in Ruby.
+**ShinyJsonLogic** is a **pure Ruby**, **zero-dependency** implementation of the JSON Logic specification.
 
-This gem exists because the official JSONLogic Ruby implementation has been incomplete and unmaintained for quite a while.
+We exist because the original Ruby implementation has been neglected for years.
 
-`ShinyJsonLogic` aims to be predictable, aligned with specs, test-driven and ready to use in Ruby's production code.
+This gem focuses on predictable behavior, strict spec alignment, high compatibility and long-term maintainability.
+
+---
+
+## 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.**
+
+If you want JSON Logic to *just work* in Ruby, this is the safe default.
 
 ---
 
@@ -23,17 +37,26 @@ Then run:
 ```bash
 bundle install
 ```
-Or install it yourself:
+
+Or install it directly:
 
 ```bash
 gem install shiny_json_logic
 ```
 
+and require it in your project:
+
+```rubyruby
+require "shiny_json_logic"
+```
+
+---
+
 ## Usage
 
 Basic usage is intentionally simple:
 
-``` ruby
+```ruby
 require "shiny_json_logic"
 
 rule = {
@@ -49,10 +72,11 @@ ShinyJsonLogic.apply(rule, data)
 # => true
 ```
 
-### Nested Logic
-You can nest rules as deeply as needed:
+### Nested logic
+
+Rules can be nested arbitrarily:
 
-``` ruby
+```ruby
 rule = {
   "if" => [
     { "var" => "financing" },
@@ -65,76 +89,92 @@ data = { "financing" => true }
 
 ShinyJsonLogic.apply(rule, data)
 # => ["apr"]
-
 ```
 
-### Supported operators
+---
 
-The goal is full JSON Logic coverage. Currently supported:
+## Supported operators
 
-#### Logic
+Our goal is **full JSON Logic coverage**.  
+Currently implemented operators include:
 
-`if, and, or, !, !!`
+### Logic
+`if`, `and`, `or`, `!`, `!!`
 
-#### Comparison
+### Comparison
+`==`, `===`, `!=`, `!==`, `>`, `>=`, `<`, `<=`
 
-`==, ===, !=, !==, >, >=, <, <=`
+### Data access
+`var`, `missing`, `missing_some`, `val`✨, `exists`✨
 
-#### Data access
+### Math
+`+`, `-`, `*`, `/`, `%`, `min`, `max`
 
-`var, missing, missing_some`
+### Strings
+`cat`, `substr`
 
-#### Math
+### Arrays
+`merge`, `in`, `??`✨ *(coalesce operator)*
 
-`+, -, *, /, %`
-`min, max`
+### Iterable operations
+`map, reduce, filter, some, all, none`
 
-#### Strings
+📌 **Note:**  
+`val`, `exists` and `??` are **only supported by ShinyJsonLogic** at the moment.
 
-`cat, substr`
+(See `lib/shiny_json_logic/operations` for the authoritative list.)
 
-#### Arrays
+---
 
-`merge, in`
+## Compatibility
 
-#### Iterable operations
-`map, reduce, filter, some, all, none`
+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.
 
-(See lib/shiny_json_logic/operations for the authoritative list.)
+---
 
 ## Development
 
 After checking out the repo:
 
-``` bash
+```bash
 bin/setup
 bundle exec rspec
 ```
 
-You can also open a console with:
+Open a console:
 
-``` bash
+```bash
 bin/console
 ```
 
-To install the gem locally:
+Install locally:
 
-``` bash
+```bash
 bundle exec rake install
 ```
 
+---
+
 ## Contributing
 
 Contributions are welcome — especially:
 
-spec alignment improvements, missing operators, edge-case tests or performance improvements
+- spec alignment improvements
+- missing operators
+- edge-case tests
+- performance improvements
 
 Please include tests with any change.
 
-Repository: https://github.com/luismoyano/shiny_json_logic
+Repository:  
+https://github.com/luismoyano/shiny_json_logic
+
+---
 
 ## License
 
 MIT License.
 
-Use it, fork it, ship it (:
+Use it. Fork it. Ship it. (:

data/lib/shiny_json_logic/engine.rb

@@ -0,0 +1,123 @@
+require "core_ext/array"
+require "core_ext/hash"
+Dir[File.join(__dir__, "operations/**/*.rb")].each do |file|
+  require file
+end
+
+module ShinyJsonLogic
+  class Engine
+    def initialize(rule, data = {})
+      @rule = rule
+      @data = data
+    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)
+            if raw_args.is_a?(Array)
+              raw_args.reverse_each { |a| stack << [a, ctx, :enter] }
+            else
+              stack << [raw_args, ctx, :enter]
+            end
+          end
+
+        when Array
+          stack << [node, ctx, :exit]
+          node.reverse_each { |n| stack << [n, ctx, :enter] }
+
+        else
+          results << node
+        end
+      end
+
+      results.last
+    end
+
+    private
+
+    attr_reader :rule, :data
+
+    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,
+      }
+    end
+
+    def collection_solvers
+      @@collection_solvers ||= {
+        "filter" => Operations::Filter,
+        "map" => Operations::Map,
+        "reduce" => Operations::Reduce,
+        "all" => Operations::All,
+        "none" => Operations::None,
+        "some" => Operations::Some,
+      }
+    end
+  end
+end

data/lib/shiny_json_logic/operations/coalesce.rb

@@ -0,0 +1,11 @@
+require "shiny_json_logic/operations/base"
+
+module ShinyJsonLogic
+  module Operations
+    class Coalesce < Base
+      def call
+        rules.compact.first
+      end
+    end
+  end
+end

data/lib/shiny_json_logic/operations/exists.rb

@@ -0,0 +1,21 @@
+require "shiny_json_logic/operations/base"
+
+module ShinyJsonLogic
+  module Operations
+    class Exists < Base
+      def call
+        current = data
+
+        Array.wrap(rules).each do |segment|
+          return false unless current.key?(segment)
+
+          current = current[segment]
+        end
+
+        true
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/shiny_json_logic/operations/val.rb

@@ -0,0 +1,12 @@
+require "shiny_json_logic/operations/base"
+
+module ShinyJsonLogic
+  module Operations
+    class Val < Base
+      def call
+        data.dig(*rules)
+      end
+    end
+  end
+end
+

data/lib/shiny_json_logic/version.rb

@@ -1,3 +1,3 @@
 module ShinyJsonLogic
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 end

data/lib/shiny_json_logic.rb

@@ -1,106 +1,8 @@
 require "shiny_json_logic/version"
-require "core_ext/array"
-require "core_ext/hash"
-require "shiny_json_logic/operations/var"
-require "shiny_json_logic/operations/missing"
-require "shiny_json_logic/operations/missing_some"
-require "shiny_json_logic/operations/if"
-require "shiny_json_logic/operations/equal"
-require "shiny_json_logic/operations/strict_equal"
-require "shiny_json_logic/operations/different"
-require "shiny_json_logic/operations/strict_different"
-require "shiny_json_logic/operations/greater"
-require "shiny_json_logic/operations/greater_equal"
-require "shiny_json_logic/operations/smaller"
-require "shiny_json_logic/operations/smaller_equal"
-require "shiny_json_logic/operations/not"
-require "shiny_json_logic/operations/or"
-require "shiny_json_logic/operations/and"
-require "shiny_json_logic/operations/inclusion"
-require "shiny_json_logic/operations/concatenation"
-require "shiny_json_logic/operations/modulo"
-require "shiny_json_logic/operations/max"
-require "shiny_json_logic/operations/min"
-require "shiny_json_logic/operations/addition"
-require "shiny_json_logic/operations/product"
-require "shiny_json_logic/operations/subtraction"
-require "shiny_json_logic/operations/division"
-require "shiny_json_logic/operations/substring"
-require "shiny_json_logic/operations/merge"
-require "shiny_json_logic/operations/double_not"
-require "shiny_json_logic/operations/filter"
-require "shiny_json_logic/operations/map"
-require "shiny_json_logic/operations/reduce"
-require "shiny_json_logic/operations/all"
-require "shiny_json_logic/operations/none"
-require "shiny_json_logic/operations/some"
+require "shiny_json_logic/engine"
 
 module ShinyJsonLogic
-  class Error < StandardError; end
-
   def self.apply(rule, data = {})
-    if rule.is_a?(Hash)
-      operation, raw_args = rule.to_a.first
-      if collection_solvers.key?(operation)
-        collection_solvers.fetch(operation).new(raw_args, data).call
-      else
-        evaluated_args =
-          if raw_args.is_a?(Array)
-            raw_args.map { |val| apply(val, data) }
-          else
-            Array.wrap(apply(raw_args, data))
-          end
-
-        solvers.fetch(operation).new(evaluated_args, data).call
-      end
-    elsif rule.is_a?(Array)
-      rule.map { |item| apply(item, data) }
-    else
-      rule
-    end
-  end
-
-  def self.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,
-    }
-  end
-
-  def self.collection_solvers
-    {
-      "filter" => Operations::Filter,
-      "map" => Operations::Map,
-      "reduce" => Operations::Reduce,
-      "all" => Operations::All,
-      "none" => Operations::None,
-      "some" => Operations::Some,
-    }
+    Engine.new(rule, data).call
   end
 end

data/shiny_json_logic.gemspec

@@ -9,24 +9,42 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Luis Moyano"]
   spec.email         = ["moyano@hey.com"]
 
-  spec.summary       = %q{An implementation of JSON Logic in Ruby that works.}
-  spec.description   = %q{JsonLogic isn’t a full programming language. It’s a small, safe way to delegate one decision. You could store a rule in a database to decide later. You could send that rule from back-end to front-end so the decision is made immediately from user input. Because the rule is data, you can even build it dynamically from user actions or GUI input. See http://jsonlogic.com}
+  spec.summary = "Production-ready JSON Logic for Ruby that just works: zero deps, Ruby 2.7+, high spec alignment."
+  spec.description = <<~DESC
+    ShinyJsonLogic is a pure-Ruby, zero-runtime-dependency implementation of the JSON Logic specification.
+  
+    - Ruby 2.7+ compatible
+    - Actively maintained and test-driven
+    - Designed for spec alignment and predictable behavior
+    - Highest support for JSON Logic operations within the Ruby ecosystem
+  
+    JSON Logic lets you represent decisions as data, so rules can be stored, transmitted, and evaluated safely.
+  DESC
   spec.homepage      = "https://github.com/luismoyano/shiny-json-logic-ruby"
   spec.license       = "MIT"
 
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+
+  spec.metadata = {
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "documentation_uri" => "#{spec.homepage}#readme",
+    "changelog_uri" => "#{spec.homepage}/blob/main/CHANGELOG.md",
+    "rubygems_mfa_required" => "true"
+  }
+
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
 
-  spec.add_runtime_dependency 'backport_dig' if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.17"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency 'byebug'
   spec.add_development_dependency 'pry'

metadata

@@ -1,42 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: shiny_json_logic
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Luis Moyano
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -79,11 +80,15 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: JsonLogic isn’t a full programming language. It’s a small, safe way to
-  delegate one decision. You could store a rule in a database to decide later. You
-  could send that rule from back-end to front-end so the decision is made immediately
-  from user input. Because the rule is data, you can even build it dynamically from
-  user actions or GUI input. See http://jsonlogic.com
+description: |
+  ShinyJsonLogic is a pure-Ruby, zero-runtime-dependency implementation of the JSON Logic specification.
+
+  - Ruby 2.7+ compatible
+  - Actively maintained and test-driven
+  - Designed for spec alignment and predictable behavior
+  - Highest support for JSON Logic operations within the Ruby ecosystem
+
+  JSON Logic lets you represent decisions as data, so rules can be stored, transmitted, and evaluated safely.
 email:
 - moyano@hey.com
 executables: []
@@ -97,6 +102,7 @@ files:
 - ".idea/vcs.xml"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -107,15 +113,18 @@ files:
 - lib/core_ext/array.rb
 - lib/core_ext/hash.rb
 - lib/shiny_json_logic.rb
+- lib/shiny_json_logic/engine.rb
 - lib/shiny_json_logic/operations/addition.rb
 - lib/shiny_json_logic/operations/all.rb
 - lib/shiny_json_logic/operations/and.rb
 - lib/shiny_json_logic/operations/base.rb
+- lib/shiny_json_logic/operations/coalesce.rb
 - lib/shiny_json_logic/operations/concatenation.rb
 - lib/shiny_json_logic/operations/different.rb
 - lib/shiny_json_logic/operations/division.rb
 - lib/shiny_json_logic/operations/double_not.rb
 - lib/shiny_json_logic/operations/equal.rb
+- lib/shiny_json_logic/operations/exists.rb
 - lib/shiny_json_logic/operations/filter.rb
 - lib/shiny_json_logic/operations/greater.rb
 - lib/shiny_json_logic/operations/greater_equal.rb
@@ -141,6 +150,7 @@ files:
 - lib/shiny_json_logic/operations/strict_equal.rb
 - lib/shiny_json_logic/operations/substring.rb
 - lib/shiny_json_logic/operations/subtraction.rb
+- lib/shiny_json_logic/operations/val.rb
 - lib/shiny_json_logic/operations/var.rb
 - lib/shiny_json_logic/truthy.rb
 - lib/shiny_json_logic/version.rb
@@ -148,7 +158,13 @@ files:
 homepage: https://github.com/luismoyano/shiny-json-logic-ruby
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/luismoyano/shiny-json-logic-ruby
+  source_code_uri: https://github.com/luismoyano/shiny-json-logic-ruby
+  documentation_uri: https://github.com/luismoyano/shiny-json-logic-ruby#readme
+  changelog_uri: https://github.com/luismoyano/shiny-json-logic-ruby/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -156,14 +172,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
-summary: An implementation of JSON Logic in Ruby that works.
+summary: 'Production-ready JSON Logic for Ruby that just works: zero deps, Ruby 2.7+,
+  high spec alignment.'
 test_files: []