plux-codegen 0.3.0

A code generator for plux-rs
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

#[cfg(test)]
mod main {
    use plux_rs::{function::Function, function_call, variable::Variable};

    extern crate plux_rs;

    mod functions {
        use std::error::Error;

        use plux_rs::variable::Variable;
        use plux_codegen::function;

        #[function]
        fn add(_: (), a: Vec<&i32>, b: &String) -> Vec<i32> {
            let mut c = [0; 1];
            c[0] = a[0] + b.parse::<i32>().unwrap();
            println!("{} + {} = {}", a[0], b, c[0]);
            c.to_vec()
        }

        #[function]
        fn sub(_: (), a: &i32, b: &i32) -> i32 {
            let c = a - b;
            println!("{} - {} = {}", a, b, c);
            c
        }

        #[function]
        fn contain_a(_: (), strs: Vec<&String>) -> Variable {
            for s in strs {
                if !s.contains("a") {
                    return Variable::Null;
                }
            }
            true.into()
        }

        #[function]
        fn log((title, code): (&Option<String>, &i32), message: &String) {
            let title = title.clone().unwrap_or("[INFO]".to_string());
            println!("{title} #{code}: {message}");
        }

        #[function]
        fn div(_: (), a: &i32, b: &i32) -> Result<i32, Box<dyn Error + Send + Sync>> {
            if b == &0 {
                return Err("division by zero".into());
            }
            Ok(a / b)
        }
    }

    #[test]
    fn serialize_add() {
        let add = functions::add();
        println!("`add` name: {}", add.name());

        let result = function_call!(add, vec![1], "2");

        assert!(result.is_ok());
        assert_eq!(result.unwrap(), Some(Variable::List(vec![3.into()])));
    }

    #[test]
    fn serialize_sub() {
        let sub = functions::sub();
        println!("`sub` name: {}", sub.name());

        let result = function_call!(sub, 3, 2);

        assert!(result.is_ok());
        assert_eq!(result.unwrap(), Some(1.into()));
    }

    #[test]
    fn serialize_contain_a() {
        let contain_a = functions::contain_a();
        println!("`contain_a` name: {}", contain_a.name());

        let mut result = function_call!(contain_a, vec!["apple", "banana"]);

        assert!(result.is_ok());
        assert_eq!(result.unwrap(), Some(true.into()));

        result = function_call!(contain_a, vec!["moon", "sun"]);

        assert!(result.is_ok());
        assert_eq!(result.unwrap(), Some(Variable::Null));
    }

    #[test]
    fn serialize_log() {
        let log = functions::log(Some("[ERROR]".to_string()), 264);
        println!("`log` name: {}", log.name());

        let mut result = function_call!(log, "It's error");

        assert!(result.is_ok());
        assert_eq!(result.unwrap(), None);

        result = function_call!(log, "It's also error");

        assert!(result.is_ok());
        assert_eq!(result.unwrap(), None);
    }

    #[test]
    fn serialize_div() {
        let div = functions::div();
        println!("`div` name: {}", div.name());

        let mut result = function_call!(div, 3, 2);

        assert!(result.is_ok());
        assert_eq!(result.unwrap(), Some(1.into()));

        result = function_call!(div, 3, 0);

        assert!(result.is_err());
    }
}