envl 0.11.4

load .envl and .envlconf
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

use envl_utils::{
    error::{EnvlError, ErrorContext},
    types::Position,
    variable::{Type, Value},
};

pub(crate) fn type_check(
    var_name: &String,
    var: Value,
    v_type: Type,
    position: &Position,
) -> Result<(), EnvlError> {
    let invalid_type_error = EnvlError {
        message: ErrorContext::InvalidType,
        position: position.clone(),
    };

    match &v_type {
        Type::Array(t) => match var {
            Value::Array(v) => {
                for e in v {
                    type_check(var_name, e, *t.clone(), position)?
                }
                Ok(())
            }
            _ => Err(invalid_type_error),
        },
        Type::Bool => match var {
            Value::Bool(_) => Ok(()),
            _ => Err(invalid_type_error),
        },
        Type::Char => match var {
            Value::Char(_) => Ok(()),
            _ => Err(invalid_type_error),
        },
        Type::Float => match var {
            Value::Float(_) => Ok(()),
            _ => Err(invalid_type_error),
        },
        Type::Int => match var {
            Value::Int(_) => Ok(()),
            _ => Err(invalid_type_error),
        },
        Type::Null => match var {
            Value::Null => Ok(()),
            _ => Err(invalid_type_error),
        },
        Type::Option(t) => match var {
            Value::Null => Ok(()),
            other => type_check(var_name, other, *t.clone(), position),
        },
        Type::String => match var {
            Value::String(_) => Ok(()),
            _ => Err(invalid_type_error),
        },
        Type::Struct(t) => match var {
            Value::Struct(v) => {
                for (name, v_type) in t {
                    if let Some(value) = v.get(name) {
                        match type_check(name, value.clone(), v_type.clone(), position) {
                            Ok(_) => {}
                            Err(err) => {
                                return Err(err);
                            }
                        }
                    } else {
                        return Err(EnvlError {
                            message: ErrorContext::Required(format!(
                                "{} in struct {}",
                                name, var_name
                            )),
                            position: position.clone(),
                        });
                    }
                }
                Ok(())
            }
            _ => Err(invalid_type_error),
        },
        Type::Uint => match var {
            Value::Uint(_) => Ok(()),
            _ => Err(invalid_type_error),
        },
    }
}