csvenum 0.1.4

Generate code for enums with associated constants from a .csv in your command line.
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

use super::RTypeTrait;
mod enumtype;
pub use enumtype::EnumType;



/// Special types have vastly different behaviour than the other types and can not be directly inferred from a string representation (except for bool).
#[derive(Debug, Eq, PartialEq)]
pub enum SpecialType {
    // the enum variant will contain the name.. or to separate it be make a named RType, which will contain building functions, expressions and declarations 
    Enum(String), // no just use the trait and store name here
    // Regex should return a as &Regex function and and is match function that takes self and a string and matches against it.
    Regex,
    /// When a property is of type singular bool then collect all variants with true and false as const array and return as Vec in match function
    Bool,
    // bool
}

impl SpecialType {

}

impl RTypeTrait for SpecialType {
    #[allow(unused_variables)]
    fn from_typestr<T: AsRef<str>>(typestr: T) -> Result<Self, super::TypeError> where Self: Sized {
        use super::TypeError;
        Err(TypeError::SPECIALTYPEPARSE)
    }
    // Call this last in a stack because it will always return SpecialType::Regex ... no real way to detect that other than looking for chaos
/*     fn from_valuestr<T: AsRef<str>>(valuestr: T) -> Result<Self, super::TypeError> where Self: Sized {
        if let Some(enumtype) = EnumType::from_value(valuestr.as_ref()) {return Ok(enumtype)}
        // if is "false" || "true" -> bool


        Ok(Self::Regex)
    } */

    fn to_typestr(&self) -> String {
        match self {
            Self::Enum(x) => {x.to_owned()},
            Self::Bool => {"bool".to_string()},
            Self::Regex => {"Regex".to_string()},
        }
    }
    fn to_typestr_no_ref(&self) -> String {
        self.to_typestr()
    }
    fn to_typestr_no_life(&self) -> String {
        self.to_typestr()
    }
    #[allow(unused_variables)]
    fn collect_lifetimes(&self, into: &mut Vec<String>) {
        // We dont have any life times here
    }
    /// Not applicable to enum since enums const be decalred as const or static, but as enum MyEnum {...}
    /// 
    /// Regex require OnceLock so they are definitely not const
    /// 
    /// 
    fn is_const(&self) -> bool {
        match self {
            Self::Bool => {true},
            Self::Regex => {true}, // will for now be true to provide a simple method until static types are fully implemented
            _ => {false},
        }        
    }
    /// For enums, values are variants, so the Rust syntax rules for Enum variants apply, it could also have the name of the enum prefixed
    /// 
    /// For Regex, values are r"" that contain weird characters, so take anything as valid i guess... but when get_or_init'ing the OnceLock<Regex> handle the except with a generated error message
    /// 
    fn value_is_valid(&self, valuestr: &str) -> bool {
        match self {
            Self::Enum(x) => {EnumType::value_is_valid_enum(x, valuestr)},
            Self::Regex => {
                true},
            Self::Bool => {
                let valstr = valuestr.trim();
                match valstr {
                    "true" | "True" | "1" | "false" | "False" | "0" => {true}
                    _ => false
                }
            },
        }
    }

    fn get_depth(&self, counter: usize) -> usize {
        match self {
            Self::Regex => {counter + 2},
            _ => {counter + 0}
        }
    }
    fn get_breadth(&self, counter: usize) -> usize {
        match self {
            Self::Regex => {counter + 5},
            _ => {counter + 0}
        }
    }
    fn wrap_valuestr(&self, valuestr: &str) -> String {
        match self {
            Self::Enum(x) => {
                if !valuestr.contains(x) {
                    format!("{}::{}",x , valuestr)
                } else {valuestr.to_string()}
            },
            Self::Regex => {
                format!("r\"{}\"", valuestr)
                //todo!("Impl wrapping for value of type regex with OnceLock get_or_init ...");
            },
            Self::Bool => {
                let valstr = valuestr.trim();
                match valstr {
                    "true" | "True" | "1"  => "true".to_string(),
                     "false" | "False" | "0" => "false".to_string(),
                    _ => "false".to_string()
                }                
            },
        }  
    }
    fn can_match_as_key(&self) -> bool {
        true
    }
}

/* #[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_stringtype_from_typestr() {
        let typestr = "str".to_string();
        let result = StringType::from_typestr(typestr).unwrap();
        let expected = StringType::str;
        assert_eq!(result, expected);

    }

} */