Struct balena_temen::Engine

pub struct Engine { /* fields omitted */ }

An expression evaluation engine

Methods

impl Engine

pub fn eval(
    &self,
    expression: &str,
    position: &Identifier,
    data: &Value,
    context: &mut Context
) -> Result<Value>

Evaluates an expression

Result can be any valid JSON value.

Arguments

• expression - An expression to evaluate
• position - An initial position for relative identifiers
• data - A JSON with variable values
• context - An evaluation context

Examples

use balena_temen::{
    ast::Identifier,
    Engine, Context, Value
};
use serde_json::json;

let engine = Engine::default();       // Default functions, filters
let mut ctx = Context::default();     // Default context
let position = Identifier::default(); // Evaluate from the root
let data = json!({
  "numbers": {
    "one": 1,
    "two": 2
  },
  "names": [
    "zero",
    "one",
    "two"
  ]
});

// Math expression

assert_eq!(
    engine.eval("2 + 3", &position, &data, &mut ctx).unwrap(),
    json!(5)
);

// Filters

assert_eq!(
    engine.eval("`Balena is great!` | SLUGIFY", &position, &data, &mut ctx).unwrap(),
    json!("balena-is-great")
);

// Variables

assert_eq!(
    engine.eval("numbers.one + numbers.two", &position, &data, &mut ctx).unwrap(),
    json!(3)
);
assert_eq!(
    engine.eval("numbers[`one`] * numbers[`two`]", &position, &data, &mut ctx).unwrap(),
    json!(2)
);

// Indirect / nested variables

assert_eq!(
    engine.eval("numbers[names[1]] + numbers[names[2]]", &position, &data, &mut ctx).unwrap(),
    json!(3)
);
assert_eq!(
    engine.eval("numbers[names.1] + numbers[names.2]", &position, &data, &mut ctx).unwrap(),
    json!(3)
);

pub fn eval_as_bool(
    &self,
    expression: &str,
    position: &Identifier,
    data: &Value,
    context: &mut Context
) -> Result<bool>

Evaluates an expression as a boolean

Result must evaluate to a boolean value otherwise it fails. Numbers, strings, ... do not evaluate to a boolean like in other languages.

Arguments

• expression - An expression to evaluate
• position - An initial position for relative identifiers
• data - A JSON with variable values
• context - An evaluation context

Examples

use balena_temen::{
    ast::Identifier,
    Engine, Context, Value
};
use serde_json::json;

let engine = Engine::default();       // Default functions, filters
let mut ctx = Context::default();     // Default context
let position = Identifier::default(); // Evaluate from the root
let data = Value::Null;               // No data (variables)

assert_eq!(
    engine.eval_as_bool("2 == 2 + 3", &position, &data, &mut ctx).unwrap(),
    json!(false)
);

// An expression MUST evaluate to a boolean otherwise the evaluation fails

assert!(
    engine.eval_as_bool("1", &position, &data, &mut ctx).is_err()
);

// Invalid syntax leads to a failure too

assert!(
    engine.eval_as_bool("true ==", &position, &data, &mut ctx).is_err()
);

Trait Implementations

impl Default for Engine

fn default() -> Engine

Creates new Engine with default set of functions, filters and the evaluation keyword.

impl From<EngineBuilder> for Engine

fn from(builder: EngineBuilder) -> Engine

Performs the conversion.