minutus 0.5.0

mruby bridge 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
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

//! Type casting logics between Rust and mruby
//!
//! | Rust type | mruby type |
//! |-----------|------------|
//! | `i8`, `i16`, `i32`, `i64`, `isize` | `Integer` |
//! | `u8`, `u16`, `u32`, `u64`, `usize` | `Integer` |
//! | `f32`, `f64` | `Float` |
//! | `String` | `String` |
//! | `Option<T>` | `T` or `nil` |
//! | `(T, U)`, `(T, U, V)`, etc | `[T, U]`, `[T, U, V]`, etc |
//! | `Vec<T>` | `Array` |
//! | `std::collections::HashMap<T, U>` | `Hash` |
//! | `minutus::types::RSymbol` | `Symbol` |
//! | `bool` | any object |
//! | `MrbData` (structs marked by `minutus::wrap`) | corresponding class |
//!
//! Any value in mruby can be cast to Rust's `bool`.
//! Rust's `bool` cast to mruby's `true` or `false`.

use crate::mruby::*;

mod array;
mod bool;
mod float;
mod hash;
mod integer;
mod option;
mod r_symbol;
mod string;
mod tuples;
mod unit;

pub use r_symbol::*;

pub type MrbResult<T> = Result<T, MrbConversionError>;

/// Trait that handles casting Rust value into mruby value.
pub trait TryIntoMrb {
    fn try_into_mrb(self, mrb: *mut minu_state) -> MrbResult<MrbValue>;
}

/// Trait that handles casting mruby value into Rust value.
pub trait TryFromMrb<Target = Self>: Sized {
    fn try_from_mrb(value: MrbValue) -> MrbResult<Target>;
}

pub trait IntoArgs {
    type Output: AsRef<[minu_value]>;

    fn into_args(self, mrb: *mut minu_state) -> MrbResult<Self::Output>;
}

impl IntoArgs for () {
    type Output = [minu_value; 0];

    fn into_args(self, _mrb: *mut minu_state) -> MrbResult<Self::Output> {
        Ok([])
    }
}

pub trait MrbValueLike {
    fn mrb(&self) -> *mut minu_state;
    fn val(&self) -> minu_value;
}

impl MrbValueLike for MrbValue {
    fn mrb(&self) -> *mut minu_state {
        self.mrb
    }
    fn val(&self) -> minu_value {
        self.val
    }
}

/// Represents values returned from mruby world.
///
/// Using `minutus::define_funcall` macro, you can define arbitrary methods to this type.
#[derive(Clone, Debug)]
pub struct MrbValue {
    pub mrb: *mut minu_state,
    pub val: minu_value,
}

impl MrbValue {
    pub fn new(mrb: *mut minu_state, val: minu_value) -> Self {
        Self { mrb, val }
    }

    /// Call mruby's method.
    ///
    /// ```
    /// let runtime = minutus::Evaluator::build();
    /// let int_123 = runtime.evaluate("123").unwrap();
    ///
    /// let inspected: String = int_123.call("inspect", ()).unwrap();
    /// assert_eq!("123", inspected);
    ///
    /// let plus_result: i64 = int_123.call("+", (100,)).unwrap();
    /// assert_eq!(223, plus_result);
    /// ```
    pub fn call<ARGS: IntoArgs, RETVAL: TryFromMrb>(
        &self,
        name: &str,
        args: ARGS,
    ) -> MrbResult<RETVAL> {
        let args = args.into_args(self.mrb)?;
        let argv = args.as_ref();
        let argc = argv.len();
        let mid = RSymbol::new(self.mrb, name).mid();
        let val =
            unsafe { minu_funcall_argv(self.mrb, self.val, mid, argc as _, argv.as_ptr() as _) };
        println!("{}", unsafe {
            String::try_from_mrb(MrbValue::new(self.mrb, minu_inspect(self.mrb, val)))?
        });
        RETVAL::try_from_mrb(Self::new(self.mrb, val))
    }
}

impl TryIntoMrb for MrbValue {
    fn try_into_mrb(self, _mrb: *mut minu_state) -> MrbResult<MrbValue> {
        Ok(self)
    }
}

impl TryFromMrb for MrbValue {
    fn try_from_mrb(value: MrbValue) -> MrbResult<Self> {
        Ok(value)
    }
}

impl std::fmt::Display for MrbConversionError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.msg)
    }
}

impl std::error::Error for MrbConversionError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        None
    }
}

#[derive(Debug)]
pub struct MrbConversionError {
    pub msg: String,
}

impl MrbConversionError {
    pub fn new(ty: &str) -> Self {
        Self {
            msg: format!("Could not convert into {}", ty),
        }
    }
}