Struct EmailAddress 

pub struct EmailAddress {
    pub local: String,
    pub domain: String,
    pub display_name: Option<String>,
}

Email address structure

Fields

local: String

Parte local (antes do @)

domain: String

Domínio (depois do @)

display_name: Option<String>

Nome de exibição opcional

Implementations

impl EmailAddress

pub fn new(email: impl AsRef<str>) -> Result<Self>

Creates new email address

Examples found in repository

examples/basic_usage.rs (line 7)

fn main() {
    println!("=== Avila Cell - Email Protocol Demo ===\n");

    // Criar endereços de email
    let from = EmailAddress::new("sender@avila.inc").unwrap();
    let to = vec![EmailAddress::new("recipient@avila.inc").unwrap()];

    println!("✓ Endereços criados:");
    println!("  De: {}", from);
    println!("  Para: {}", to[0]);

    // Criar email
    let mut email = Email::new(
        from.clone(),
        to,
        "Teste Avila Cell".to_string(),
        "Esta é uma mensagem de teste do ecossistema Avila!".to_string(),
    );

    // Adicionar CC
    email.add_cc(EmailAddress::new("cc@avila.inc").unwrap());

    // Adicionar header customizado
    email.add_header("X-Avila-Version".to_string(), "0.1.0".to_string());

    println!("\n✓ Email criado:");
    println!("  Message-ID: {}", email.id);
    println!("  Assunto: {}", email.subject);
    println!("  CC: {:?}", email.cc);

    // Converter para RFC 5322
    let rfc5322 = email.to_rfc5322();

    println!("\n✓ Formato RFC 5322:");
    println!("{}", "=".repeat(60));
    println!("{}", rfc5322);
    println!("{}", "=".repeat(60));

    // Validar endereços
    println!("\n✓ Validações:");
    println!("  {} é válido? {}", from, from.is_valid());

    let invalid = EmailAddress::new("test@localhost").unwrap();
    println!("  {} é válido? {}", invalid, invalid.is_valid());

    println!("\n✅ Demo concluído com sucesso!");
}

examples/gmail_client.rs (line 23)

fn main() {
    println!("=== Avila Cell - Gmail SMTP Client Demo ===\n");

    // Configuração do Gmail
    let _smtp_server = NetworkAddress::new("smtp.gmail.com", 587); // TLS/STARTTLS
    // let smtp_server = NetworkAddress::new("smtp.gmail.com", 465); // SSL

    println!("📧 Conectando ao Gmail SMTP...");
    println!("   Servidor: smtp.gmail.com:587");
    println!("   Protocolo: SMTP com STARTTLS\n");

    // NOTA: Para usar Gmail você precisa:
    // 1. Ativar "App Passwords" na sua conta Google
    // 2. Ou usar OAuth2 (não implementado ainda)

    let username = "seu-email@gmail.com";
    let _app_password = "sua-senha-de-app"; // 16 caracteres sem espaços

    // Criar email
    match EmailAddress::new(username) {
        Ok(from) => {
            match EmailAddress::new("destinatario@example.com") {
                Ok(to_addr) => {
                    let to = vec![to_addr];

    let mut email = Email::new(
        from.clone(),
        to,
        "Teste do Avila Cell via Gmail".to_string(),
        r#"Olá!

Este é um email enviado usando o Avila Cell,
uma biblioteca Rust nativa para protocolos de email.

Características:
- 100% Rust nativo
- Sem dependências externas pesadas
- Suporte a SMTP, POP3 e IMAP
- Compatível com Gmail, Outlook, etc.

Enviado por: Avila Cell v0.1.0
"#.to_string(),
    );

    // Headers adicionais
    email.add_header("X-Mailer".to_string(), "Avila Cell 0.1.0".to_string());
    email.add_header("X-Priority".to_string(), "3".to_string()); // Normal priority

    println!("✉️  Email preparado:");
    println!("   De: {}", email.from);
    println!("   Para: {:?}", email.to);
    println!("   Assunto: {}", email.subject);
    println!("   Message-ID: {}\n", email.id);

    // DIFERENÇAS DO BASIC USAGE:
    println!("🔍 Diferenças do exemplo básico:");
    println!("   ❌ Básico: Apenas cria estruturas de dados");
    println!("   ✅ Gmail: Conexão real com servidor SMTP");
    println!("   ❌ Básico: Não envia nada");
    println!("   ✅ Gmail: Envia email de verdade");
    println!("   ❌ Básico: Sem autenticação");
    println!("   ✅ Gmail: Autenticação com credenciais");
    println!("   ❌ Básico: Sem criptografia");
    println!("   ✅ Gmail: TLS/SSL obrigatório\n");

    // Conectar (comentado pois precisa de credenciais reais)
    println!("⚠️  AVISO: Conexão desabilitada neste demo");
    println!("   Para enviar emails reais:");
    println!("   1. Configure suas credenciais do Gmail");
    println!("   2. Ative 'App Passwords' no Google");
    println!("   3. Descomente o código de envio abaixo\n");

    /*
    // Descomentar para enviar de verdade:
    match SmtpClient::connect(smtp_server).await {
        Ok(mut client) => {
            println!("✅ Conectado ao Gmail!");

            // HELO/EHLO
            client.helo("avila.inc").await?;
            println!("✅ HELO enviado");

            // Autenticação (necessário implementar STARTTLS + AUTH)
            // client.auth_plain(username, app_password).await?;

            // Enviar email
            client.send_email(&email).await?;
            println!("✅ Email enviado com sucesso!");

            client.quit().await?;
        }
        Err(e) => {
            eprintln!("❌ Erro ao conectar: {}", e);
        }
    }
    */

    println!("📊 Comparação detalhada:");
    println!("\n┌─────────────────────┬──────────────┬─────────────┐");
    println!("│ Recurso             │ Basic Usage  │ Gmail Client│");
    println!("├─────────────────────┼──────────────┼─────────────┤");
    println!("│ Criar estruturas    │      ✅      │      ✅     │");
    println!("│ Validar emails      │      ✅      │      ✅     │");
    println!("│ RFC 5322 format     │      ✅      │      ✅     │");
    println!("│ Conexão TCP         │      ❌      │      ✅     │");
    println!("│ TLS/SSL             │      ❌      │      ✅     │");
    println!("│ Autenticação SMTP   │      ❌      │      ✅     │");
    println!("│ Envio real          │      ❌      │      ✅     │");
    println!("│ STARTTLS            │      ❌      │      ✅     │");
    println!("└─────────────────────┴──────────────┴─────────────┘");

    println!("\n✅ Demo concluído!");
    println!("\n💡 Próximos passos:");
    println!("   - Implementar STARTTLS");
    println!("   - Implementar AUTH PLAIN/LOGIN");
    println!("   - Implementar OAuth2 para Gmail");
    println!("   - Adicionar suporte a anexos");
    println!("   - Implementar HTML multipart");
                }
                Err(e) => eprintln!("Erro ao criar endereço de destino: {}", e),
            }
        }
        Err(e) => eprintln!("Erro ao criar endereço de origem: {}", e),
    }
}

pub fn to_string(&self) -> String

Converts to complete string

pub fn is_valid(&self) -> bool

Validates email format

Examples found in repository

examples/basic_usage.rs (line 43)

fn main() {
    println!("=== Avila Cell - Email Protocol Demo ===\n");

    // Criar endereços de email
    let from = EmailAddress::new("sender@avila.inc").unwrap();
    let to = vec![EmailAddress::new("recipient@avila.inc").unwrap()];

    println!("✓ Endereços criados:");
    println!("  De: {}", from);
    println!("  Para: {}", to[0]);

    // Criar email
    let mut email = Email::new(
        from.clone(),
        to,
        "Teste Avila Cell".to_string(),
        "Esta é uma mensagem de teste do ecossistema Avila!".to_string(),
    );

    // Adicionar CC
    email.add_cc(EmailAddress::new("cc@avila.inc").unwrap());

    // Adicionar header customizado
    email.add_header("X-Avila-Version".to_string(), "0.1.0".to_string());

    println!("\n✓ Email criado:");
    println!("  Message-ID: {}", email.id);
    println!("  Assunto: {}", email.subject);
    println!("  CC: {:?}", email.cc);

    // Converter para RFC 5322
    let rfc5322 = email.to_rfc5322();

    println!("\n✓ Formato RFC 5322:");
    println!("{}", "=".repeat(60));
    println!("{}", rfc5322);
    println!("{}", "=".repeat(60));

    // Validar endereços
    println!("\n✓ Validações:");
    println!("  {} é válido? {}", from, from.is_valid());

    let invalid = EmailAddress::new("test@localhost").unwrap();
    println!("  {} é válido? {}", invalid, invalid.is_valid());

    println!("\n✅ Demo concluído com sucesso!");
}

pub fn with_name(self, name: impl Into<String>) -> Self

Sets display name

pub fn to_rfc5322(&self) -> String

Formats for RFC 5322 (with display name if present)

Trait Implementations

impl Clone for EmailAddress

fn clone(&self) -> EmailAddress

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EmailAddress

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for EmailAddress

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for EmailAddress

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for EmailAddress

fn eq(&self, other: &EmailAddress) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for EmailAddress

impl StructuralPartialEq for EmailAddress