mtots 0.1.2

The mtots scripting language
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

use crate::mtry;
use crate::ArgSpec;
use crate::NativeModule;
use crate::RcStr;
use crate::Value;
use regex::Regex;

pub const NAME: &str = "a.regex";

pub(super) fn new() -> NativeModule {
    NativeModule::new(NAME, |m| {
        m.class::<Regex, _>("Regex", |cls| {
            cls.doc("Binding to Rust/Cargo's 'regex' crate");
            cls.sfunc("__call", ["pattern"], "", |globals, args, _| {
                let mut args = args.into_iter();
                let pattern = args.next().unwrap().into_string()?;
                let re = mtry!(Regex::new(&pattern));
                globals.new_handle::<Regex>(re).map(From::from)
            });
            cls.ifunc(
                "find",
                ArgSpec::builder()
                    .req("text")
                    .def("start", ())
                    .def("end", ()),
                "",
                |owner, globals, args, _| {
                    let mut args = args.into_iter();
                    let text = args.next().unwrap().into_string()?;
                    let len = text.len();
                    let start = args.next().unwrap().to_start_index(len)?;
                    let end = args.next().unwrap().to_end_index(len)?;
                    let match_ = owner.borrow().find(&text[start..end]);
                    Ok(match match_ {
                        Some(match_) => globals
                            .new_handle(OwnedMatch {
                                text: text.clone(),
                                start: start + match_.start(),
                                end: start + match_.end(),
                            })?
                            .into(),
                        None => Value::Nil,
                    })
                },
            );
            cls.ifunc(
                "replace",
                ["text", "replacement"],
                "",
                |owner, _globals, args, _| {
                    let mut args = args.into_iter();
                    let text = args.next().unwrap().into_string()?;
                    let replacement = args.next().unwrap().into_string()?;
                    Ok(owner
                        .borrow()
                        .replace(&text, replacement.str())
                        .into_owned()
                        .into())
                },
            );
        });
        m.class::<OwnedMatch, _>("Match", |cls| {
            cls.str(|match_| match_.str().into());
            cls.repr(|match_| format!("Match({:?})", match_.str()).into());
            cls.ifunc("start", (), "", |owner, _, _, _| {
                Ok(owner.borrow().start.into())
            });
            cls.ifunc("end", (), "", |owner, _, _, _| {
                Ok(owner.borrow().end.into())
            });
            cls.ifunc("str", (), "", |owner, _, _, _| {
                Ok(owner.borrow().str().into())
            });
        });
    })
}

pub struct OwnedMatch {
    text: RcStr,
    start: usize,
    end: usize,
}

impl OwnedMatch {
    pub fn str(&self) -> &str {
        &self.text[self.start..self.end]
    }
}