bhgames/json-logic-ruby

Build complex rules, serialize them as JSON, and execute them in ruby

json-logic-ruby

Build complex rules, serialize them as JSON, and execute them in ruby.

json-logic-ruby is a ruby parser for JsonLogic. Other libraries are available for parsing this logic for Python and JavaScript at that link!

DANGER WILL ROBINSON!

This Ruby version of jwadhams/json-logic does not have the same functionality as the original Javascript version. In particular, method is not implemented at all and add_operation can only define operations with exactly one parameter. There are probably other deficiencies as well.

This does not mean that JsonLogic is not useful... IMHO, it is. However, the class of problems it can solve is a subset of the class of problems that jwadhams/json-logic can solve.

Contributions of expertise, time and energy are welcome to correct these deficiencies and bring the Ruby version up to parity with the Javascript version. Inquire within if you are interested.

Installation

gem install json_logic

Why use JsonLogic?

If you're looking for a way to share logic between front-end and back-end code, and even store it in a database, JsonLogic might be a fit for you.

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.

JsonLogic has no setters, no loops, no functions or gotos. One rule leads to one decision, with no side effects and deterministic computation time.

Virtues

1. Terse.
2. Consistent. {"operator" : ["values" ... ]} Always.
3. Secure. We never eval(). Rules only have read access to data you provide, and no write access to anything.
4. Flexible. Easy to add new operators, easy to build complex structures.

Examples

simple

JSONLogic.apply({ "==" => [1, 1] }, {})
# => true

This is a simple rule, equivalent to 1 == 1. A few things about the format:

1. The operator is always in the 「key」 position. There is only one key per JsonLogic rule.
2. The values are typically an array.
3. Each value can be a string, number, boolean, array (non-associative), or null

Compound

Here we're beginning to nest rules.

JSONLogic.apply(
{ "and" => [
  { ">" => [3,1] },
  { "<" => [1,3] }]
}, {})

# => true

In an infix language (like JavaScript) this could be written as:

( (3 > 1) && (1 < 3) )

Data-Driven

Obviously these rules aren't very interesting if they can only take static literal data. Typically jsonLogic will be called with a rule object and a data object. You can use the var operator to get attributes of the data object:

 JSONLogic.apply(
  { "var" => ["a"] }, # Rule
  { "a" => 1, "b" => 2 }  # Data
 )
 # => 1

If you like, we support syntactic sugar on unary operators to skip the array around values:

JSONLogic.apply(
  { "var" => "a" },
  { "a" => 1, "b" => 2 }
 )
# => 1

You can also use the var operator to access an array by numeric index:

JSONLogic.apply(
  { "var" => 1 },
  ["apple", "banana", "carrot"]
)
# => "banana"

Here's a complex rule that mixes literals and data. The pie isn't ready to eat unless it's cooler than 110 degrees, and filled with apples.

rules = JSON.parse(%Q|{ "and" : [
  {"<" : [ { "var" : "temp" }, 110 ]},
  {"==" : [ { "var" : "pie.filling" }, "apple" ] }
] }|)

data = JSON.parse(%Q|{ "temp" : 100, "pie" : { "filling" : "apple" } }|)

JSONLogic.apply(rules, data)

# => true

json-logic-ruby's Issues

Thank you!

Not an actual issue, just wanted to say thank you so much for creating this gem!

Logic doesn't work like the JS Library

JSONLogic.apply({ "+" => [{"var": "age"}, 1] }, {"age": 75})

returns NoMethodError: undefined method `var' for JSONLogic::Operation:Class

On JSONLogic.com, is 76.

Provide way to ensure all variables have values provided

The JS library exposes a function called uses_data which is useful to check if all variables have data in provided data.

jwadhams/json-logic-js#39 (comment)

It'd be awesome to have this in this ruby implementation too so that we can do validation that all the variable values are available before trying to evaluate (which could lead to weird errors)

There is no 0.2 version

https://rubygems.org/gems/json_logic stores only 0.1 there is no version supporting added add_method from here: 48568b6

Add size or length operator?

Hi, would you accept a PR to add a size or length operator? I would implement it as described here: jwadhams/json-logic#4. Though that issue provides a workaround it's a lot of code to do a very simple thing. Feel free to close this after replying.

"IN" Operator Fails When Accessed via "VAR" Operator

Problem Statement:

While trying to access a subset array from within a superset array using the "All" operator, I found that the "IN" operator does not function correctly when an array is accessed via the "VAR" operator.

Observed Behavior:
In the rule example below, the "IN" operator fails to correctly validate if all elements of the subset array are contained within the superset array:

Rule:

{ "all": [ {"var": "subset"}, {"in": [{"var": ""}, {"var": "superset"}]} ] }
Data

{ "subset": ["apple", "banana", "orange"], "superset": ["apple", "banana", "orange", "grape", "pear"] }

Expected Outcome:
The evaluation of this rule should yield True, as the subset array is fully included in the superset array.

Actual Outcome:
The rule incorrectly returns False.

Hint / Workaround:
When I specify the array directly within the rule instead of referencing it with the "VAR" operator, the "IN" operator behaves as expected:

Working Rule:
{ "all": [ {"var": "subset"}, {"in": [{"var": ""}, ["apple", "banana", "orange", "grape", "pear"]]} ] }

I suspect there might be a bug in the way the "IN" operator processes references to arrays. Your assistance in identifying and resolving the root cause of this behavior would be greatly appreciated.

`in` operator doesn't work correctly with `var`

I believe this is a bug, but please tell me if it's just my expectation that needs to be corrected:

irb(main):028:0> data = {"code": "45736123"}
=> {:code=>"45736123"}
irb(main):029:0> rule = {"in": ["123",{"var": "code"}]}
=> {:in=>["123", {:var=>"code"}]}
irb(main):030:0> JSONLogic.apply(rule,data)
=> false

Works fine when hardcoded:

irb(main):031:0> rule = {"in": ["123","45736123"]}
=> {:in=>["123", "45736123"]}
irb(main):032:0> JSONLogic.apply(rule,data)
=> true
irb(main):033:0> JSONLogic.apply(rule,nil)
=> true

Javascript only

This so-called 'gem' only works as advertised with Javascript.

Don't waste your time...

-- cc

Functional differences between this and original JS port

I've noticed that the operations in this port work entirely different then they do in the original JS port.
Specifically here:

json-logic-ruby/lib/json_logic/operation.rb

Line 117 in 97b4b5d

return LAMBDAS[operator.to_s].call(interpolated, data) if is_standard?(operator)

JSONLogic is defined to accept the elements in an array as the argument to an operation.
However, your operations accept an array and the original data object.

With all the testing I've done so far, it seems like everything officially supported in the JS port works the same in this Ruby port.
Ex)

rule = {+: [1, 2]}
data = {}
JSONLogic.apply(rule, data) # 3

The result of this will be 3 in both ports ✅

However, if you were to define something like this in ruby:

rule = {+: [{var: 'data'}]}
data = {data: [1,2]}
JSONLogic.apply(rule, data) # 3

and in JS

rule = {"+": [{"var": "data"}]}
data = {"data": [1,2]}
jsonLogic.apply(rule, data) # 1

You end up with 3 in Ruby and 1 in JS. ❌

Ultimately this leads to inconsistencies when trying to develop cross-platform.

Compare 2 JSON logic expressions for equality.

Is there any way to compare 2 Json logic expressions for equality other than doing a deep compare of the hash object?

Are you looking for maintainers?

I noticed that the repo is not being actively maintained for quite a long time. I would be pleased to dedicate same time to help in the maintenance of this gem if you agreed. Please let me know what do you think @bhgames.

Date Comparison within Range in === Operator

I have a problem when trying to compare dates within a range using the === operator. The current implementation does not support this.

range = Date.parse('2024-01-01')..Date.parse('2024-12-31')
date = Date.parse('2024-07-22')

rule = {
  "===" => [
    { "var" => "range" },
    { "var" => "date" }
  ]
}

data = {
  "date" => date,
  "range" => range
}

result = JSONLogic.apply(rule, data)
# expected result is true, but in all cases it returns false

We could add the command "==="

json-logic-ruby/lib/json_logic/operation.rb

Line 88 in 1fe6722

'===' => ->(v, d) { v[0] == v[1] },

 '==='   => ->(v, d) { v[0] === v[1] }, 

IN operator fails when nil is passed as the array to search in

I've noticed that the in operator is failing when receiving nil values as the array.

Context:

We have been using JSONLogic for a couple of years now to evaluate rules on serialized objects at runtime. Most of the time, we don't know the actual values of the variables used in the rules since they are built by serializing objects retrieved from our database.

Current behavior:

When the variable (array to search in) doesn't exist in the object, a nil value is passed as the array, so in that case the gem is failing due to a NoMethodError: undefined method include?' for nil:NilClass`.

Here you can see an example:

rule = {"in" => ["value_to_search", {"var" => "array"}]}
variable = {"array" => nil} (Consider that nil is the value after some processing at runtime)

JSONLogic.apply(rule, variable)

The output:

== operator incorrectly compares floats and ints

According to the spec at https://jsonlogic.com/, the == operator should return true when comparing inputs such as 1.0 and 1

Symbol handling seems spotty

Seems like symbolized keys in both data and filters give JSONLogic some grief.

[1] pry(main)> require 'json_logic'
=> true
[2] pry(main)> require 'active_support/core_ext/hash'
=> true

[3] pry(main)> filter = { "in": [ { "var": "foo.bar" }, [5] ] }
=> {:in=>[{:var=>"foo.bar"}, [5]]}
[4] pry(main)> good = { foo: { bar: 5 } }
=> {:foo=>{:bar=>5}}
[5] pry(main)> bad = { foo: { bar: 10 } }
=> {:foo=>{:bar=>10}}

[6] pry(main)> JSONLogic.apply(filter, good)
NoMethodError: undefined method `var' for JSONLogic::Operation:Class
from /opt/rh/rh-ruby24/root/usr/local/share/gems/gems/json_logic-0.3/lib/json_logic/operation.rb:117:in `perform'

[9] pry(main)> JSONLogic.apply(filter.deep_stringify_keys, good.deep_stringify_keys)
=> true

Given the common use of symbols and the way a number of database libraries return JSON/JSONB data, it may be worth making it symbol/string agnostic.