l3_fn_config 0.0.2-alpha.1

Parsing l3.toml config files
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 crate::{
    configs::LambdaRuntimeConfig, configs::NodeLambdaConfig, configs::PythonLambdaConfig,
    ConfigParseError, NodeVersion, OptionallyParsable, PythonVersion,
};

impl OptionallyParsable<&toml::Table> for LambdaRuntimeConfig {
    fn has_value(l3_t: &&toml::Table) -> bool {
        l3_t.contains_key("node_opts")
            || l3_t.contains_key("node_version")
            || l3_t.contains_key("python_opts")
            || l3_t.contains_key("python_version")
    }

    fn parse(t: &toml::Table) -> Result<Self, ConfigParseError> {
        Ok(Self {
            node: parse_node_config(t)?,
            python: parse_python_config(t)?,
        })
    }
}

fn parse_node_config(t: &toml::Table) -> Result<Option<NodeLambdaConfig>, ConfigParseError> {
    let version = parse_node_version(t.get("node_version"))?;
    match t.get("node_opts") {
        Some(toml::Value::Table(node_opts_t)) => Ok(Some(NodeLambdaConfig {
            version: match parse_node_version(node_opts_t.get("version"))? {
                Some(node_opts_version) => {
                    if version
                        .as_ref()
                        .map(|v| v == &node_opts_version)
                        .unwrap_or(true)
                    {
                        Some(node_opts_version)
                    } else {
                        return Err(ConfigParseError::Misconfigured {
                            actual: "node_version and node_opts.version do not match".into(),
                            expected: "use node_version or node_opts.version".into(),
                            field: "node_opts.version".into(),
                        });
                    }
                }
                None => version,
            },
        })),
        None => {
            if version.is_none() {
                Ok(None)
            } else {
                Ok(Some(NodeLambdaConfig { version }))
            }
        }
        _ => panic!(),
    }
}

fn parse_node_version(
    node_version_v: Option<&toml::Value>,
) -> Result<Option<NodeVersion>, ConfigParseError> {
    match node_version_v {
        Some(toml::Value::String(version_s)) => {
            Ok(Some(NodeVersion::try_from(version_s.as_str())?))
        }
        Some(toml::Value::Integer(version_i)) => {
            Ok(Some(NodeVersion::try_from(version_i.to_string().as_str())?))
        }
        None => Ok(None),
        _ => panic!(),
    }
}

fn parse_python_config(t: &toml::Table) -> Result<Option<PythonLambdaConfig>, ConfigParseError> {
    let version = parse_python_version(t.get("python_version"))?;
    match t.get("python_opts") {
        Some(toml::Value::Table(python_opts_t)) => Ok(Some(PythonLambdaConfig {
            version: match parse_python_version(python_opts_t.get("version"))? {
                Some(python_opts_version) => {
                    if version
                        .as_ref()
                        .map(|v| v == &python_opts_version)
                        .unwrap_or(true)
                    {
                        Some(python_opts_version)
                    } else {
                        return Err(ConfigParseError::Misconfigured {
                            actual: "python_version and python_opts.version do not match".into(),
                            expected: "use python_version or python_opts.version".into(),
                            field: "python_opts.version".into(),
                        });
                    }
                }
                None => version,
            },
        })),
        None => {
            if version.is_none() {
                Ok(None)
            } else {
                Ok(Some(PythonLambdaConfig { version }))
            }
        }
        _ => panic!(),
    }
}

fn parse_python_version(
    node_version_v: Option<&toml::Value>,
) -> Result<Option<PythonVersion>, ConfigParseError> {
    match node_version_v {
        Some(toml::Value::String(version_s)) => {
            Ok(Some(PythonVersion::try_from(version_s.as_str())?))
        }
        Some(toml::Value::Float(version_f)) => Ok(Some(PythonVersion::try_from(
            version_f.to_string().as_str(),
        )?)),
        None => Ok(None),
        _ => panic!(),
    }
}