egui_form 0.8.0

Form validation for egui
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

use eframe::NativeOptions;
use egui::CentralPanel;
use egui_form::validator::field_path;
use egui_form::Form;
use egui_form::FormField;
use validator::Validate;

#[derive(Validate, Debug)]
struct Test {
    #[validate(length(min = 3, max = 10))]
    pub user_name: String,
    #[validate(email)]
    pub email: String,
    #[validate(nested)]
    pub nested: Nested,
    #[validate(nested)]
    pub vec: Vec<Nested>,
}

#[derive(Validate, Debug)]
struct Nested {
    #[validate(range(
        min = 1,
        max = 10,
        message = "Custom Message: Must be between 1 and 10"
    ))]
    pub test: u64,
}

fn form_ui(ui: &mut egui::Ui, test: &mut Test) {
    let mut form = Form::new().add_report(
        egui_form::validator::ValidatorReport::new(test.validate()).with_translation(|error| {
            // Since validator doesn't have default messages, we have to provide our own
            if let Some(msg) = &error.message {
                return msg.clone();
            }

            match error.code.as_ref() {
                "email" => "Invalid email".into(),
                "length" => format!(
                    "Must be between {} and {} characters long",
                    error.params["min"], error.params["max"]
                )
                .into(),
                _ => format!("Validation Failed: {}", error.code).into(),
            }
        }),
    );

    FormField::new(&mut form, "user_name")
        .label("User Name")
        .ui(ui, egui::TextEdit::singleline(&mut test.user_name));
    FormField::new(&mut form, "email")
        .label("Email")
        .ui(ui, egui::TextEdit::singleline(&mut test.email));
    FormField::new(&mut form, field_path!("nested", "test"))
        .label("Nested Test")
        .ui(ui, egui::Slider::new(&mut test.nested.test, 0..=11));
    FormField::new(&mut form, field_path!("vec", 0, "test"))
        .label("Vec Test")
        .ui(
            ui,
            egui::DragValue::new(&mut test.vec[0].test).range(0..=11),
        );

    if let Some(Ok(())) = form.handle_submit(&ui.button("Submit"), ui) {
        println!("Form submitted: {test:?}");
    }
}

fn main() -> eframe::Result<()> {
    let mut test = Test {
        user_name: "testfiwuehfwoi".to_string(),
        email: "garbage".to_string(),
        nested: Nested { test: 0 },
        vec: vec![Nested { test: 0 }],
    };

    eframe::run_ui_native(
        "Egui Validator Validation",
        NativeOptions::default(),
        move |ui, _frame| {
            CentralPanel::default().show_inside(ui, |ui| {
                form_ui(ui, &mut test);
            });
        },
    )
}

#[cfg(test)]
mod tests {
    use super::*;
    use egui_form::validator::field_path;
    use egui_form::{EguiValidationReport, IntoFieldPath};

    #[test]
    fn test_validate() {
        let test = Test {
            user_name: "testfiwuehfwoi".to_string(),
            email: "garbage".to_string(),
            nested: Nested { test: 0 },
            vec: vec![Nested { test: 0 }],
        };

        let report = egui_form::validator::ValidatorReport::validate(test);

        assert!(report
            .get_field_error(field_path!("user_name").into_field_path())
            .is_some());
        assert!(report
            .get_field_error(field_path!("email").into_field_path())
            .is_some());
        assert!(report
            .get_field_error(field_path!("nested", "test").into_field_path())
            .is_some());
        assert!(report
            .get_field_error(field_path!("vec", 0, "test").into_field_path())
            .is_some());

        assert_eq!(report.error_count(), 4);
    }
}