leptos-forms-rs 1.3.0

🚀 Type-safe, reactive form handling library for Leptos applications. Production-ready with 100% test success rate, cross-browser compatibility, and comprehensive validation. Built with Rust/WASM for high performance.
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

//! Derive macro example
//!
//! This module demonstrates the derive macro functionality.

use leptos_forms_rs_macro::Form;
use crate::core::traits::Form;
use crate::core::types::FieldValue;

// #[derive(Form, Clone, serde::Serialize, serde::Deserialize, PartialEq, Debug)]
struct UserForm {
    #[field(required = true, min_length = 3, max_length = 50)]
    name: String,
    
    #[field(email = true, required = true)]
    email: String,
    
    #[field(default = "en")]
    language: String,
    
    #[field(default = false)]
    newsletter: bool,
}

pub fn demonstrate_derive_macro() {
    // Test default values
    let form = UserForm::default_values();
    println!("Default form: {:?}", form);
    
    // Test field metadata
    let metadata = UserForm::field_metadata();
    println!("Field metadata count: {}", metadata.len());
    
    // Test field access
    let mut form = UserForm {
        name: "John Doe".to_string(),
        email: "john@example.com".to_string(),
        language: "en".to_string(),
        newsletter: true,
    };
    
    // Test get_field_value
    let name_value = form.get_field_value("name");
    println!("Name value: {:?}", name_value);
    
    // Test set_field_value
    form.set_field_value("name", FieldValue::String("Jane Doe".to_string()));
    println!("Updated form: {:?}", form);
    
    // Test validation
    let validation_result = form.validate();
    println!("Validation result: {:?}", validation_result);
}

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

    #[test]
    fn test_derive_macro_basic() {
        let form = UserForm::default_values();
        assert_eq!(form.name, "");
        assert_eq!(form.email, "");
        assert_eq!(form.language, "en");
        assert_eq!(form.newsletter, false);
    }

    #[test]
    fn test_derive_macro_field_metadata() {
        let metadata = UserForm::field_metadata();
        assert_eq!(metadata.len(), 4);
        
        let name_field = metadata.iter().find(|f| f.name == "name").unwrap();
        assert!(name_field.is_required);
        
        let email_field = metadata.iter().find(|f| f.name == "email").unwrap();
        assert!(email_field.is_required);
    }

    #[test]
    fn test_derive_macro_field_access() {
        let mut form = UserForm {
            name: "John Doe".to_string(),
            email: "john@example.com".to_string(),
            language: "en".to_string(),
            newsletter: true,
        };
        
        assert_eq!(form.get_field_value("name"), FieldValue::String("John Doe".to_string()));
        assert_eq!(form.get_field_value("email"), FieldValue::String("john@example.com".to_string()));
        
        form.set_field_value("name", FieldValue::String("Jane Doe".to_string()));
        assert_eq!(form.name, "Jane Doe");
    }

    #[test]
    fn test_derive_macro_validation() {
        let valid_form = UserForm {
            name: "John Doe".to_string(),
            email: "john@example.com".to_string(),
            language: "en".to_string(),
            newsletter: true,
        };
        
        assert!(valid_form.validate().is_ok());
        
        let invalid_form = UserForm {
            name: "Jo".to_string(), // Too short
            email: "invalid-email".to_string(), // Invalid email
            language: "en".to_string(),
            newsletter: true,
        };
        
        assert!(invalid_form.validate().is_err());
    }
}