mailidator 0.1.0

A lightweight Rust library for checking email address misspellings
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

//! Basic usage example for the email spell checker library

use mailidator::{Config, Mailidator};

fn main() {
    println!("Email Spell Checker - Basic Usage Examples\n");

    // Create a default spell checker
    let checker = Mailidator::default();

    // Example 1: Common Gmail typos
    println!("=== Example 1: Gmail Typos ===");
    let gmail_typos = vec![
        "user@gmaik.com",
        "john.doe@gmial.com",
        "test@gnail.com",
        "admin@gmail.co",
    ];

    for email in gmail_typos {
        match checker.check(email) {
            Some(suggestion) => {
                println!("Input: {} -> Suggestion: {}", email, suggestion.full());
                println!(
                    "  Address: {}, Domain: {}",
                    suggestion.address(),
                    suggestion.domain()
                );
            }
            None => {
                println!("Input: {email} -> No suggestion needed");
            }
        }
    }

    // Example 2: Yahoo and other provider typos
    println!("\n=== Example 2: Other Provider Typos ===");
    let other_typos = vec![
        "user@yaho.com",
        "test@outlok.com",
        "admin@hotmial.com",
        "contact@icluod.com",
    ];

    for email in other_typos {
        if let Some(suggestion) = checker.check(email) {
            println!("Did you mean {} instead of {}?", suggestion.full(), email);
        } else {
            println!("{email} looks correct!");
        }
    }

    // Example 3: Valid emails (should not suggest corrections)
    println!("\n=== Example 3: Valid Emails ===");
    let valid_emails = vec![
        "user@gmail.com",
        "test@yahoo.com",
        "admin@outlook.com",
        "contact@hotmail.com",
    ];

    for email in valid_emails {
        match checker.check(email) {
            Some(suggestion) => {
                println!("Unexpected suggestion for {}: {}", email, suggestion.full());
            }
            None => {
                println!("{email} ✓ (valid)");
            }
        }
    }

    // Example 4: Custom configuration
    println!("\n=== Example 4: Custom Configuration ===");

    let mut config = Config::default();
    // Add custom domains for a specific organization
    config.domains.extend(vec![
        "company.org".to_string(),
        "mycompany.biz".to_string(),
        "internal.local".to_string(),
    ]);
    // Make matching stricter
    config.threshold = 0.3;

    let custom_checker = Mailidator::new(config);

    let custom_emails = vec![
        "employee@compny.org", // Should suggest company.org
        "user@mycompay.biz",   // Should suggest mycompany.biz
        "admin@internl.local", // Should suggest internal.local
    ];

    for email in custom_emails {
        if let Some(suggestion) = custom_checker.check(email) {
            println!("Custom suggestion: {} -> {}", email, suggestion.full());
        } else {
            println!("No custom suggestion for: {email}");
        }
    }

    // Example 5: Practical usage pattern
    println!("\n=== Example 5: Practical Usage Pattern ===");

    fn validate_email_with_suggestion(email: &str) -> Result<String, String> {
        let checker = Mailidator::default();

        // Basic format validation
        if !email.contains('@') || email.starts_with('@') || email.ends_with('@') {
            return Err("Invalid email format".to_string());
        }

        // Check for typos
        match checker.check(email) {
            Some(suggestion) => Err(format!("Did you mean '{}'?", suggestion.full())),
            None => Ok(email.to_string()),
        }
    }

    let test_emails = vec![
        "user@gmail.com", // Valid
        "user@gmaik.com", // Typo
        "invalid-email",  // Invalid format
        "user@yahoo.com", // Valid
        "user@yaho.com",  // Typo
    ];

    for email in test_emails {
        match validate_email_with_suggestion(email) {
            Ok(valid_email) => {
                println!("✓ '{valid_email}' is valid");
            }
            Err(error) => {
                println!("✗ '{email}': {error}");
            }
        }
    }
}