tailwag_forms 0.3.0

The form definition crate for the tailwag suite. See the tailwag crate for full details.
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

use std::path::Path;

use serde::{Deserialize, Serialize};
pub use tailwag_forms_macros as macros;

#[derive(Serialize, Deserialize)]
pub struct Form {
    pub button_name: String,
    pub fields: Vec<FormField>,
}

impl Form {
    #[allow(unused)]
    pub fn save_json(
        &self,
        filepath: &str,
    ) -> Result<(), std::io::Error> {
        let json_def = serde_json::to_string(self)?;
        let dir = Path::new(filepath).parent().unwrap_or(Path::new(filepath));
        std::fs::create_dir_all(dir).expect("Failed to create directories.");
        std::fs::write(filepath, json_def.as_bytes())?;
        Ok(())
    }
}

#[derive(Default, Serialize, Deserialize)]
pub enum InputType {
    #[default]
    Text,
    Password,
    Number,
    Checkbox,
}

#[derive(Default, Serialize, Deserialize)]
pub struct FormField {
    name: String, // TODO: Verify this is unique with underscores
    #[serde(rename = "type")]
    field_type: InputType,
    is_required: bool,
    label: Option<String>,
    placeholder: Option<String>,
    initial_value: Option<String>,
    validate_regex: Option<String>,
}

impl FormField {
    pub fn text(name: &str) -> Self {
        Self {
            name: name.to_string(),
            field_type: InputType::Text,
            ..Default::default()
        }
    }

    pub fn password(name: &str) -> Self {
        Self {
            name: name.to_string(),
            field_type: InputType::Password,
            ..Default::default()
        }
    }
    pub fn number(name: &str) -> Self {
        Self {
            name: name.to_string(),
            field_type: InputType::Number,
            ..Default::default()
        }
    }
    pub fn boolean(name: &str) -> Self {
        Self::bool(name)
    }
    pub fn bool(name: &str) -> Self {
        Self {
            name: name.to_string(),
            field_type: InputType::Checkbox,
            ..Default::default()
        }
    }
}

macro_rules! builder_method {
    ($attr_name:ident, Some(String)) => {
        pub fn $attr_name(
            mut self,
            $attr_name: &str,
        ) -> Self {
            self.$attr_name = Some($attr_name.to_string());
            self
        }
    };
    ($attr_name:ident, Some($type:ty)) => {
        pub fn $attr_name(
            mut self,
            $attr_name: $type,
        ) -> Self {
            self.$attr_name = Some($attr_name);
            self
        }
    };
    ($attr_name:ident, String) => {
        pub fn $attr_name(
            mut self,
            $attr_name: &str,
        ) -> Self {
            self.$attr_name = $attr_name.to_string();
            self
        }
    };
    ($attr_name:ident, $type:ty) => {
        pub fn $attr_name(
            mut self,
            $attr_name: $type,
        ) -> Self {
            self.$attr_name = $attr_name;
            self
        }
    };
}

/// Builders
impl FormField {
    builder_method!(is_required, bool);
    builder_method!(label, Some(String));
    builder_method!(placeholder, Some(String));
    builder_method!(initial_value, Some(String));
    builder_method!(validate_regex, Some(String));
    builder_method!(name, String);
}

pub trait GetForm {
    fn get_form() -> Form;
}