rtea 0.1.0

Makes writing TCL extensions in Rust ergonomic.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use std::cell::RefCell;

use rtea::*;

mod common;

use common::TestInterpreter;

#[test]
fn eval() -> Result<(), String> {
    let test_interp = TestInterpreter::new();
    let interp = test_interp.as_ref();
    assert_eq!(interp.eval("expr 5 + 5")?, TclStatus::Ok);
    let result = interp.get_obj_result();
    assert_eq!(interp.get_string(result), "10");
    Ok(())
}

#[test]
fn create_command() -> Result<(), String> {
    let test_interp = TestInterpreter::new();
    let interp = test_interp.as_ref();

    fn cmd(interp: &Interpreter, args: Vec<&str>) -> Result<TclStatus, String> {
        if args[1] == "fail" {
            Err("doing as told".to_string())
        } else {
            interp.set_result("pass");
            Ok(TclStatus::Ok)
        }
    }

    interp.create_command("mycmd", cmd)?;
    interp.eval("mycmd not_fail")?;
    let result = interp.get_obj_result();
    assert_eq!(interp.get_string(result), "pass");

    let eval = interp
        .eval("mycmd fail")
        .expect_err("cmd should error on 'fail' as argv[1]");
    let result = interp.get_string(interp.get_obj_result());
    assert_eq!(eval, result);

    Ok(())
}

#[test]
fn create_stateful_command() -> Result<(), String> {
    let test_interp = TestInterpreter::new();
    let interp = test_interp.as_ref();

    fn cmd(
        interp: &Interpreter,
        counter: &RefCell<usize>,
        _args: Vec<&str>,
    ) -> Result<TclStatus, String> {
        let mut val = counter.borrow_mut();
        interp.set_result(&val.to_string());
        *val += 1;

        Ok(TclStatus::Ok)
    }

    StatefulCommand::new(cmd, RefCell::<usize>::new(0)).attach_command(interp, "counter")?;
    for i in 0..10 {
        interp.eval("counter")?;
        assert_eq!(i.to_string(), interp.get_string(interp.get_obj_result()));
    }

    Ok(())
}

#[module_init(Bogus, "0.0.0")]
fn test_init(interp: &Interpreter) -> Result<TclStatus, String> {
    fn cmd(interp: &Interpreter, _args: Vec<&str>) -> Result<TclStatus, String> {
        interp.set_result("pass");
        Ok(TclStatus::Ok)
    }

    interp.create_command("mycmd", cmd)
}

#[test]
fn init_wrapper() -> Result<(), String> {
    let test_interp = TestInterpreter::new();
    assert_eq!(Bogus_Init(test_interp.as_ptr()), TclStatus::Ok);

    let interp = test_interp.as_ref();
    interp.eval("mycmd")?;
    let result = interp.get_obj_result();
    assert_eq!(interp.get_string(result), "pass");

    Ok(())
}