clips-bindings 0.1.2+clips-6.4.2

Safe, idiomatic, custom-written Rust bindings for the CLIPS 6.4.2 embedding API
Documentation
//! Values, multifields, and direct function calls.

use clips_bindings::*;

#[test]
fn evaluates_typed_values() {
    let mut environment = Environment::new().unwrap();
    assert_eq!(environment.eval("(+ 40 2)").unwrap().as_i64(), Some(42));
    assert_eq!(environment.eval("(/ 7.0 2.0)").unwrap().as_f64(), Some(3.5));
    assert_eq!(
        environment
            .eval("(str-cat hello \" world\")")
            .unwrap()
            .as_str(),
        Some("hello world")
    );
}

#[test]
fn builds_and_reads_multifields() {
    let environment = Environment::new().unwrap();
    let multifield = environment
        .multifield_builder(3)
        .unwrap()
        .integer(42)
        .float(3.5)
        .string("hello")
        .unwrap()
        .build();

    assert_eq!(multifield.len(), 3);
    assert_eq!(multifield.get(0).unwrap().as_i64(), Some(42));
    assert_eq!(multifield.get(1).unwrap().as_f64(), Some(3.5));
    assert_eq!(multifield.get(2).unwrap().as_str(), Some("hello"));
}

#[test]
fn creates_standalone_typed_values() {
    let environment = Environment::new().unwrap();
    assert_eq!(environment.create_integer(42).as_i64(), Some(42));
    assert_eq!(environment.create_float(3.5).as_f64(), Some(3.5));
    assert_eq!(
        environment.create_symbol("ada").unwrap().as_str(),
        Some("ada")
    );
    assert_eq!(
        environment.create_string("a string").unwrap().as_str(),
        Some("a string")
    );
    assert_eq!(
        environment.create_instance_name("ada").unwrap().as_str(),
        Some("ada")
    );
    assert_eq!(environment.create_boolean(true).as_bool(), Some(true));
    assert_eq!(environment.create_boolean(false).as_bool(), Some(false));
    assert!(matches!(
        environment.create_symbol("nul\0inside"),
        Err(Error::InteriorNul)
    ));
}

#[test]
fn accepts_created_values_in_builders_and_calls() {
    let mut environment = Environment::new().unwrap();
    environment
        .build("(deftemplate person (slot name) (slot age (type INTEGER)))")
        .unwrap();

    // Created values outlive the builders they are handed to, which is the
    // point of the shared-borrow builder API.
    let name = environment.create_symbol("Ada").unwrap();
    let age = environment.create_integer(36);

    let fact = environment
        .fact_builder("person")
        .unwrap()
        .value("name", &name)
        .unwrap()
        .value("age", &age)
        .unwrap()
        .assert()
        .unwrap();
    assert_eq!(fact.slot("name").unwrap().as_str(), Some("Ada"));
    assert_eq!(fact.slot("age").unwrap().as_i64(), Some(36));

    let modified = fact
        .modifier()
        .unwrap()
        .value("age", &environment.create_integer(37))
        .unwrap()
        .modify()
        .unwrap();
    assert_eq!(modified.slot("age").unwrap().as_i64(), Some(37));

    let sum = environment
        .function_call(2)
        .unwrap()
        .value(&age)
        .unwrap()
        .value(&environment.create_integer(6))
        .unwrap()
        .call("+")
        .unwrap();
    assert_eq!(sum.as_i64(), Some(42));

    let multifield = environment
        .multifield_builder(2)
        .unwrap()
        .value(&name)
        .unwrap()
        .value(&age)
        .unwrap()
        .build();
    assert_eq!(multifield.len(), 2);
    assert_eq!(multifield.get(0).unwrap().as_str(), Some("Ada"));
}

#[test]
fn refuses_values_created_by_another_environment() {
    let mut owner = Environment::new().unwrap();
    owner.build("(deftemplate person (slot name))").unwrap();
    let stranger = Environment::new().unwrap();
    let foreign = stranger.create_symbol("Ada").unwrap();

    let mut builder = owner.fact_builder("person").unwrap();
    assert!(matches!(
        builder.value("name", &foreign),
        Err(Error::ForeignEnvironment)
    ));
}

#[test]
fn converts_between_strings_and_multifields() {
    let environment = Environment::new().unwrap();
    let multifield = environment.string_to_multifield("a b 3 4.5").unwrap();
    assert_eq!(multifield.len(), 4);
    assert_eq!(multifield.get(0).unwrap().as_str(), Some("a"));
    assert_eq!(multifield.get(2).unwrap().as_i64(), Some(3));
    assert_eq!(multifield.get(3).unwrap().as_f64(), Some(4.5));
    assert_eq!(multifield.implode(), "a b 3 4.5");

    // `implode$` quotes and escapes strings, unlike symbols.
    let quoted = environment.string_to_multifield("\"one two\"").unwrap();
    assert_eq!(quoted.implode(), "\"one two\"");

    let empty = environment.string_to_multifield("").unwrap();
    assert!(empty.is_empty());
    assert_eq!(empty.implode(), "");
}

#[test]
fn calls_functions_without_parsing_expressions() {
    let environment = Environment::new().unwrap();
    let result = environment
        .function_call(2)
        .unwrap()
        .integer(20)
        .integer(22)
        .call("+")
        .unwrap();
    assert_eq!(result.as_i64(), Some(42));
}