mrubyedge 1.0.7

mruby/edge is yet another mruby that is specialized for running on WASM
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

extern crate mec_mrbc_sys;
extern crate mrubyedge;

mod helpers;
use helpers::*;
use std::rc::Rc;
use mrubyedge::yamrb::helpers::mrb_define_cmethod;
use mrubyedge::yamrb::vm::*;
use mrubyedge::yamrb::value::*;
use mrubyedge::Error;

fn prelude_dummy_error_func(vm: &mut VM) {
  let klass = vm.object_class.clone();
  mrb_define_cmethod(vm, klass, "dummy_raise", Box::new(mrb_test_dummy_raise));
}

fn mrb_test_dummy_raise(_vm: &mut VM, _args: &[Rc<RObject>]) -> Result<Rc<RObject>, Error> {
  Err(Error::RuntimeError("Intentional Rust Error".to_string()))
}

#[test]
fn rust_raise_test() {
    let code = "
    def test_raise
      dummy_raise
    end
    ";
    let binary = mrbc_compile("raise_rust", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    prelude_dummy_error_func(&mut vm);
    vm.run().unwrap();

    // Assert
    let args = vec![];
    let result = mrb_funcall(&mut vm, None, "test_raise", &args)
        .err();
    assert_eq!(&result.unwrap().message(), "Intentional Rust Error");
}

#[test]
fn rust_raise_nest_test() {
    let code = "
    def test_raise
      dummy_raise
    end

    def shim
      test_raise
    end
    ";
    let binary = mrbc_compile("raise_rust_2", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    prelude_dummy_error_func(&mut vm);
    vm.run().unwrap();

    // Assert
    let args = vec![];
    let result = mrb_funcall(&mut vm, None, "shim", &args)
        .err();
    assert_eq!(&result.unwrap().message(), "Intentional Rust Error");
}

#[test]
fn rust_raise_rescue_test() {
    let code = "
    def test_raise
      dummy_raise
    rescue => e
      \"rescued: #{e.message}\"
    end
    ";
    let binary = mrbc_compile("raise_rust_3", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    prelude_dummy_error_func(&mut vm);
    vm.run().unwrap();

    // Assert
    let args = vec![];
    let result: String = mrb_funcall(&mut vm, None, "test_raise", &args)
        .unwrap().as_ref().try_into().unwrap();
    assert_eq!(&result, "rescued: Intentional Rust Error");
}

#[test]
fn rust_nomethod_rescue_test() {
    let code = "
    def test_raise
      dummy_nomethod
    rescue => e
      \"rescued: #{e.message}\"
    end
    ";
    let binary = mrbc_compile("raise_rust_4", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    vm.run().unwrap();

    // Assert
    let args = vec![];
    let result: String = mrb_funcall(&mut vm, None, "test_raise", &args)
        .unwrap().as_ref().try_into().unwrap();
    assert_eq!(&result, "rescued: Method not found: dummy_nomethod");
}

#[test]
fn rust_noname_rescue_test() {
    let code = "
    def test_raise
      NoName.new
    rescue => e
      \"rescued: #{e.message}\"
    end
    ";
    let binary = mrbc_compile("raise_rust_5", code);
    let mut rite = mrubyedge::rite::load(&binary).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);
    vm.run().unwrap();

    // Assert
    let args = vec![];
    let result: String = mrb_funcall(&mut vm, None, "test_raise", &args)
        .unwrap().as_ref().try_into().unwrap();
    assert_eq!(&result, "rescued: Cannot found name: NoName");
}