oxidar 0.0.0

A lightweight web framework written in rust inspired by Django.
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
139

use std::{collections::HashMap, rc::Rc};

#[derive(Debug, Clone)]
pub enum TemplateVar {
    Str(String),
    Num(f32),
    Bool(bool),
    None,
    Indexable(HashMap<&'static str, TemplateVar>),
}

impl TemplateVar {
    fn split_first_dot(input: &str) -> (&str, &str) {
        if let Some(index) = input.find('.') {
            let first_part = &input[..index];
            let second_part = &input[index + 1..];
            (first_part, second_part)
        } else {
            (input, "")
        }
    }

    pub fn string(&self) -> String {
        match self {
            TemplateVar::Str(s) => s.to_string(),
            TemplateVar::Num(n) => n.to_string(),
            TemplateVar::Bool(b) => b.to_string(),
            TemplateVar::None => "None".to_string(),
            TemplateVar::Indexable(..) => {
                todo!()
            }
        }
    }

    pub fn resolve(&self, key: &str) -> &TemplateVar {
        let (a, b) = Self::split_first_dot(key);

        if a == "" && b == "" {
            return self;
        }

        match self {
            TemplateVar::Indexable(hash_map) => {
                if a == "" {
                    todo!()
                }

                return match hash_map.get(a) {
                    Some(s) => s.resolve(b),
                    None => todo!(),
                };
            }
            _ => todo!(),
        }
    }
}

macro_rules! from_template_var_num {
    ($from:ty) => {
        impl From<&$from> for TemplateVar {
            fn from(value: &$from) -> Self {
                TemplateVar::Num(value.clone() as f32)
            }
        }

        impl From<$from> for TemplateVar {
            fn from(value: $from) -> Self {
                TemplateVar::Num(value as f32)
            }
        }
    };
}

from_template_var_num!(i8);
from_template_var_num!(i16);
from_template_var_num!(i32);
from_template_var_num!(i64);
from_template_var_num!(i128);

from_template_var_num!(u8);
from_template_var_num!(u16);
from_template_var_num!(u64);
from_template_var_num!(u128);

from_template_var_num!(f32);
from_template_var_num!(f64);
from_template_var_num!(usize);

macro_rules! from_template_var_str {
    ($from:ty) => {
        impl From<$from> for TemplateVar {
            fn from(value: $from) -> Self {
                TemplateVar::Str(value.to_string())
            }
        }
    };
}

from_template_var_str!(&String);
from_template_var_str!(String);
from_template_var_str!(char);
from_template_var_str!(&char);
from_template_var_str!(&str);

pub trait ToTemplateVar {
    fn to_template_var(&self) -> TemplateVar;
}

impl<T> From<&T> for TemplateVar
where
    T: ToTemplateVar,
{
    fn from(value: &T) -> Self {
        value.to_template_var()
    }
}

impl<T> From<&Option<T>> for TemplateVar
where
    TemplateVar: From<T>,
    T: Clone,
{
    fn from(value: &Option<T>) -> Self {
        match value {
            Some(s) => TemplateVar::from(s.clone()),
            None => TemplateVar::None,
        }
    }
}

impl<T> From<&Rc<T>> for TemplateVar
where
    TemplateVar: From<T>,
    T: Clone,
{
    fn from(value: &Rc<T>) -> Self {
        TemplateVar::from((**value).clone())
    }
}