logisheets_controller 0.6.0

the core of LogiSheets
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

use crate::calc_engine::connector::Connector;

use super::{CalcValue, CalcVertex, Value};
use logisheets_parser::ast;

pub fn calc<C>(args: Vec<CalcVertex>, fetcher: &mut C) -> CalcVertex
where
    C: Connector,
{
    args.into_iter()
        .map(|arg| fetcher.get_calc_value(arg))
        .try_fold(AndResult::Blank, |and, e| match e {
            CalcValue::Scalar(s) => cal_and_result(and, s),
            CalcValue::Range(r) => r.into_iter().try_fold(and, cal_and_result),
            CalcValue::Cube(_) => Err(ast::Error::Ref),
            CalcValue::Union(_) => todo!(),
        })
        .map_or_else(
            |e| CalcVertex::from_error(e),
            |ok| match ok {
                AndResult::Bool(b) => CalcVertex::from_bool(b),
                AndResult::Blank => CalcVertex::from_error(ast::Error::Value),
            },
        )
}

enum AndResult {
    Bool(bool),
    Blank,
}

fn cal_and_result(and: AndResult, v: Value) -> Result<AndResult, ast::Error> {
    match v {
        Value::Boolean(b) => match and {
            AndResult::Bool(and_result_bool) => Ok(AndResult::Bool(and_result_bool && b)),
            AndResult::Blank => Ok(AndResult::Bool(b)),
        },
        Value::Number(n) => match and {
            AndResult::Bool(b) => Ok(AndResult::Bool(b && n != 0_f64)),
            AndResult::Blank => Ok(AndResult::Bool(n != 0_f64)),
        },
        Value::Error(e) => Err(e),
        _ => Ok(and),
    }
}

#[cfg(test)]
mod tests {
    use super::super::utils::tests_utils::TestFetcher;
    use super::calc;
    use super::{CalcValue, CalcVertex, Value};
    use logisheets_base::matrix_value::MatrixValue;
    use logisheets_parser::ast::Error;

    #[test]
    fn and_test() {
        let args1 = vec![
            CalcVertex::from_bool(true),
            CalcVertex::from_number(1_f64),
            CalcVertex::from_string(String::from("test")),
            CalcVertex::Value(CalcValue::Scalar(Value::Blank)),
            CalcVertex::Value(CalcValue::Range(MatrixValue::from(vec![
                vec![Value::Boolean(true)],
                vec![Value::Number(1_f64)],
            ]))),
        ];
        let mut fetcher = TestFetcher {};
        let res1 = calc(args1, &mut fetcher);
        assert!(matches!(
            res1,
            CalcVertex::Value(CalcValue::Scalar(Value::Boolean(true))),
        ));

        let args2 = vec![CalcVertex::from_bool(true), CalcVertex::from_bool(false)];
        let res2 = calc(args2, &mut fetcher);
        assert!(matches!(
            res2,
            CalcVertex::Value(CalcValue::Scalar(Value::Boolean(false))),
        ));

        let args3 = vec![CalcVertex::from_bool(true), CalcVertex::from_number(0_f64)];
        let res3 = calc(args3, &mut fetcher);
        assert!(matches!(
            res3,
            CalcVertex::Value(CalcValue::Scalar(Value::Boolean(false))),
        ));

        let args4 = vec![
            CalcVertex::from_bool(true),
            CalcVertex::Value(CalcValue::Range(MatrixValue::from(vec![
                vec![Value::Boolean(true)],
                vec![Value::Number(0_f64)],
            ]))),
        ];
        let res4 = calc(args4, &mut fetcher);
        assert!(matches!(
            res4,
            CalcVertex::Value(CalcValue::Scalar(Value::Boolean(false))),
        ));
    }

    #[test]
    fn and_error() {
        let args1 = vec![
            CalcVertex::from_string("test".to_string()),
            CalcVertex::Value(CalcValue::Scalar(Value::Blank)),
            CalcVertex::Value(CalcValue::Range(MatrixValue::from(vec![
                vec![Value::Text("test".to_string())],
                vec![Value::Blank],
            ]))),
        ];
        let mut fetcher = TestFetcher {};
        let res1 = calc(args1, &mut fetcher);
        assert!(matches!(
            res1,
            CalcVertex::Value(CalcValue::Scalar(Value::Error(Error::Value))),
        ));

        let args2 = vec![
            CalcVertex::from_error(Error::Ref),
            CalcVertex::from_error(Error::Div0),
        ];
        let res2 = calc(args2, &mut fetcher);
        assert!(matches!(
            res2,
            CalcVertex::Value(CalcValue::Scalar(Value::Error(Error::Ref))),
        ));

        let args3 = vec![CalcVertex::Value(CalcValue::Range(MatrixValue::from(
            vec![vec![Value::Error(Error::Div0)]],
        )))];
        let res3 = calc(args3, &mut fetcher);
        assert!(matches!(
            res3,
            CalcVertex::Value(CalcValue::Scalar(Value::Error(Error::Div0))),
        ));
    }
}