Trying to evaluate "a" != "b":

Invalid binary operation, left: "a", right: "b", operation: Not equal

I found an error "UnrecognizedToken { token: (8, Token(14, "-"), 9)"
ex. : let rs = eval.eval("{a: -3}")?;

and no error if: let rs = eval.eval("{a: 0-3}")?;

please fix this.

Currently, attributes not defined in the context are interpreted as null.

Prior to version 0.2.0, null was not supported in any binary operations.

This meant that expressions with missing attribute errored: not because the attribute was missing, but because binary operations on null were not supported.

Missing attributes can come from:

1. the expression authors mistyping an identifier.
2. attributes in one version of the context, but not in another.

We'd like expression authors to be able detect the absence of an attribute in their expressions:

e.g.

attr_v2 ? attr_v2 == 'value' : attr == 'value'
attr_v2 && attr_v2 == 'value'

This issue is to make undefined attributes error, BUT make is_truthy for undefined return false.

We need to make sure our implementation isn't missing anything large,

• We'll need to add some complex tests that capture a use case (a targeting field of a nimbus experiment is a good candidate)

• Do a comparison against https://github.com/mozilla/mozjexl/blob/master/test/evaluator/Evaluator.js to ensure we are covering all test cases.

I have a feeling we'll need to do some reordering of the expressions in the .lalrpop file once we test against a complex example

Similar to #15, binary expressions with boolean values are not available. AND and OR are supported, but

==
!=
XOR

…and others are missing.

Without a boolean comparison (==) or NOT (!) this makes boolean context values much less useful.

There are a few unwraps in the code base that should be errors instead

Additionally the lifetime stuation with the errors is a little annoying

Probably will have two prs here, a mandatory replacement of the unwraps and an overall cleanup.

There are a bunch of failing test with #[should_panic]

We should fix those

Trying to evaluate var == null when var is not defined in the context leads to the following error result value:

Invalid binary operation, left: null, right: null, operation: Equal

Any use of ! in an expression (see mozjexl) leads to a parse error.

A couple of pieces here

• Add rust docs to the eval functions of the Evaluator
• Add comments/docs to the .lalrpop file, for future maintainablility

We need to support custom transforms for things like versionCompare.

Ref: https://github.com/mozilla/mozjexl#transforms
Ref: https://searchfox.org/mozilla-central/source/toolkit/components/utils/FilterExpressions.jsm

Consider the following:

let evaluator = Evaluator::new();

let context = value!({
    "foo": null,
});

let expr = "foo".to_string();

let r = evaluator.eval_in_context(&expr, context).unwrap();

In the above snippet, foo will evaluate to null. This is the same behavior that is seen in jexl. If we expand this to an equality test, however, you will see that the binary comparison is not currently possible:

...
let expr = "foo == null".to_string();
let r = evaluator.eval_in_context(&expr, context).unwrap();

This will produce the following error:

thread '...' panicked at 'called `Result::unwrap()` on an `Err` value: UndefinedIdentifier("null")', jexl-eval/src/lib.rs:816:59

Equality comparisons should allow for null identifiers.