envuse_parser/transformers/
parser.rs

1use super::super::errors::parser_error::ParseError;
2
3use super::super::parser::ast::Variable;
4use super::transformer_list::TransformerList;
5use super::value_types::ValueType;
6use std::collections::BTreeMap;
7
8pub struct Parser;
9
10impl Parser {
11    pub fn to_parse_variable(
12        transformer_list: &TransformerList,
13        variable: &Variable,
14        envs: &BTreeMap<String, Option<String>>,
15    ) -> Result<ValueType, ParseError> {
16        let default_type = String::from("String");
17        let transform_type = variable
18            .variable_type
19            .clone()
20            .unwrap_or(default_type)
21            .to_lowercase();
22
23        let transformer = match transformer_list.get(&transform_type) {
24            Some(transformer) => transformer,
25            _ => {
26                do yeet ParseError::new(
27                    format!("Type {} is not valid type", transform_type),
28                    variable.span,
29                )
30            }
31        };
32
33        let value_env = envs.get(&variable.name).unwrap_or(&None);
34
35        if variable.nullable && value_env.is_none() && variable.default_value.is_none() {
36            return Ok(ValueType::Null);
37        }
38
39        let value_to_transform = if let Some(value_env) = value_env {
40            value_env.to_string()
41        } else if let Some(expression) = variable.default_value.as_ref() {
42            if let Some(default_value) = expression.as_default_value() {
43                default_value.value.to_string()
44            } else {
45                do yeet ParseError::new(format!("Expression cannot found error"), variable.span)
46            }
47        } else {
48            do yeet ParseError::new(
49                format!("{} value cannot be null", &variable.name),
50                variable.span,
51            )
52        };
53
54        Ok(transformer
55            .as_ref()
56            .parse(transform_type, value_to_transform))
57    }
58}