eval 0.4.3

Expression evaluator
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


use {Function, Functions, Value, to_value};
use math::Math;
use error::Error;


pub struct BuiltIn {}

impl BuiltIn {
    pub fn new() -> Functions {
        let mut functions = Functions::new();
        functions.insert("min".to_owned(), create_min_fuction());
        functions.insert("max".to_owned(), create_max_fuction());
        functions.insert("len".to_owned(), create_len_fuction());
        functions.insert("is_empty".to_owned(), create_is_empty_fuction());
        functions.insert("array".to_owned(), create_array_function());
        functions
    }
}

#[derive(PartialEq)]
enum Compare {
    Min,
    Max,
}

fn create_min_fuction() -> Function {
    compare(Compare::Min)
}

fn create_max_fuction() -> Function {
    compare(Compare::Max)
}

fn compare(compare: Compare) -> Function {
    Function {
        max_args: None,
        min_args: Some(1),
        compiled: Box::new(move |values| {
            let mut prev: Result<Value, Error> = Err(Error::Custom("can't find min value."
                .to_owned()));

            for value in values {
                match value {
                    Value::Array(array) => {
                        for value in array {
                            if prev.is_ok() {
                                if compare == Compare::Min {
                                    if value.lt(prev.as_ref().unwrap())? == to_value(true) {
                                        prev = Ok(value)
                                    }
                                } else if value.gt(prev.as_ref().unwrap())? == to_value(true) {
                                    prev = Ok(value)
                                }
                            } else {
                                prev = Ok(value);
                            }
                        }
                    }
                    _ => {
                        if prev.is_ok() {
                            if compare == Compare::Min {
                                if value.lt(prev.as_ref().unwrap())? == to_value(true) {
                                    prev = Ok(value)
                                }
                            } else if value.gt(prev.as_ref().unwrap())? == to_value(true) {
                                prev = Ok(value)
                            }
                        } else {
                            prev = Ok(value);
                        }
                    }
                }
            }
            prev
        }),
    }
}


fn create_is_empty_fuction() -> Function {
    Function {
        max_args: Some(1),
        min_args: Some(1),
        compiled: Box::new(|values| match *values.first().unwrap() {
            Value::String(ref string) => Ok(to_value(string.is_empty())),
            Value::Array(ref array) => Ok(to_value(array.is_empty())),
            Value::Object(ref object) => Ok(to_value(object.is_empty())),
            Value::Null => Ok(to_value(true)),
            _ => Ok(to_value(false)),
        }),
    }
}

fn create_len_fuction() -> Function {
    Function {
        max_args: Some(1),
        min_args: Some(1),
        compiled: Box::new(|values| {
            let value = values.first().unwrap();
            match *value {
                Value::String(ref string) => Ok(to_value(string.len())),
                Value::Array(ref array) => Ok(to_value(array.len())),
                Value::Object(ref object) => Ok(to_value(object.len())),
                Value::Null => Ok(to_value(0)),
                _ => {
                    Err(Error::Custom(format!("len() only accept string, array, object and \
                                               null. But the given is: {:?}",
                                              value)))
                }
            }
        }),
    }
}

fn create_array_function() -> Function {
    Function::new(|values| Ok(to_value(values)))
}