rune 0.14.2

The Rune Language, an embeddable dynamic programming language for Rust.
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

#![cfg(feature = "capture-io")]

prelude!();

use crate::termcolor::{ColorChoice, StandardStream};

macro_rules! capture {
    ($($tt:tt)*) => {{
        let capture = crate::modules::capture_io::CaptureIo::new();
        let module = crate::modules::capture_io::module(&capture).context("building capture module")?;

        let mut context = Context::with_config(false).context("building context")?;
        context.install(module).context("installing module")?;

        let source = Source::memory(stringify!($($tt)*)).context("building source")?;

        let mut sources = Sources::new();
        sources.insert(source).context("inserting source")?;

        let mut diagnostics = Diagnostics::new();

        let mut options = Options::default();
        options.script(true);

        let unit = prepare(&mut sources)
            .with_context(&context)
            .with_diagnostics(&mut diagnostics)
            .with_options(&options)
            .build();

        if !diagnostics.is_empty() {
            let mut writer = StandardStream::stderr(ColorChoice::Always);
            diagnostics.emit(&mut writer, &sources)?;
        }

        let unit = Arc::new(unit.context("building unit")?);

        let context = context.runtime().context("constructing runtime context")?;
        let context = Arc::new(context);

        let mut vm = Vm::new(context, unit);
        vm.call(Hash::EMPTY, ()).context("calling main")?;
        capture.drain_utf8().context("draining utf-8 capture")?
    }};
}

macro_rules! test_case {
    ($expected:expr, {$($prefix:tt)*}, $($format:tt)*) => {{
        let string = capture!($($prefix)* println!($($format)*));
        assert_eq!(string, concat!($expected, "\n"), "Expecting println!");

        let string = capture!($($prefix)* print!($($format)*));
        assert_eq!(string, $expected, "Expecting print!");

        let string: String = rune!($($prefix)* format!($($format)*));
        assert_eq!(string, $expected, "Expecting format!");
    }}
}

#[test]
fn format_macros() -> Result<()> {
    test_case!("Hello World!", {}, "Hello World!");
    test_case!("Hello World!", {}, "Hello {}!", "World");
    test_case!(
        "Hello World!",
        {
            let pos = "Hello";
        },
        "{pos} {}!",
        "World"
    );
    test_case!(
        "Hello World!",
        {
            let pos = "Not Hello";
        },
        "{pos} {}!",
        "World",
        pos = "Hello"
    );
    Ok(())
}