rurust 0.1.0 

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

use ffi;
use builder;
use util;

use std;
use libc;

use Value;

/// A Ruby virtual machine.
pub struct VM;

static mut VM_EXISTS: bool = false;

#[derive(Debug)]
pub enum ErrorKind
{
    /// An internal VM error.
    VM(String),
    /// An exception was thrown.
    Exception(Value),
}

impl VM
{
    pub fn new() -> Result<Self, ErrorKind> {
        unsafe {
            if VM_EXISTS {
                Err(ErrorKind::VM("can only have one Ruby VM at a time".to_owned()))
            } else {
                ffi::ruby_init();
                VM_EXISTS = true;

                Ok(VM)
            }
        }
    }

    pub fn eval(&mut self, code: &str) -> Result<Value, ErrorKind> {
        let mut state: libc::c_int = 0;

        let result = unsafe {
            ffi::rb_eval_string_protect(util::c_string(code).as_ptr(), &mut state)
        };

        if state == 0 {
            Ok(Value::from(result))
        } else {
            Err(ErrorKind::Exception(self.consume_exception().unwrap()))
        }
    }

    pub fn class<S>(&mut self, name: S) -> builder::ClassBuilder
        where S: Into<String> {
        builder::ClassBuilder::new(name)
    }

    pub fn consume_exception(&mut self) -> Option<Value> {
        let exception = self.current_exception();

        unsafe {
            ffi::rb_set_errinfo(ffi::Qnil);
        }

        exception
    }

    // TODO: make this return None if err is nil
    pub fn current_exception(&self) -> Option<Value> {
        Some(Value::from(unsafe { ffi::rb_errinfo() }))
    }
}

impl std::ops::Drop for VM
{
    fn drop(&mut self) {
        unsafe {
            VM_EXISTS = false;
            ffi::ruby_cleanup(0);
        };
    }
}

#[cfg(test)]
describe! vm {
    before_each { let mut vm = VM::new().unwrap(); }

    it "can eval a simple assignment" {
        vm.eval("a = 1");
    }
}