💻 Exemplos: Capítulo 11: Modularização, Visibilidade e Workspaces

Especialização em Sistemas com Rust • Demonstrações Práticas Compiláveis

🎯 Objetivo dos Exemplos

Apresentar a arquitetura modular do Rust através do sistema de módulos mod, regras de visibilidade estrita (pub, pub(crate), privado por padrão), reexportação com pub use, e organização em múltiplos crates via Cargo Workspaces.

1. Código Fonte Completo (src/main.rs)

//! Arquitetura Modular, Visibilidade e Encapsulamento em Rust

// 1. Módulo Interno de Criptografia e Segurança
mod seguranca {
    // Submódulo privado acessível apenas dentro de 'seguranca'
    mod cifras {
        pub fn aplicar_xor_mask(dados: &[u8], chave: u8) -> Vec<u8> {
            dados.iter().map(|b| b ^ chave).collect()
        }
    }

    // Estrutura pública com campos públicos e privados
    pub struct CofreCredencial {
        pub identificador: String, // Campo público acessível livremente
        chave_hash: Vec<u8>,       // Campo privado! Encapsulamento estrito
    }

    impl CofreCredencial {
        // Construtor público obrigatório porque 'chave_hash' é privado
        pub fn novo(id: &str, segredo: &[u8]) -> Self {
            let hash_protegido = cifras::aplicar_xor_mask(segredo, 0x5A);
            Self {
                identificador: String::from(id),
                chave_hash: hash_protegido,
            }
        }

        // Método visível apenas dentro da crate atual (pub(crate))
        pub(crate) fn verificar_integridade(&self) -> bool {
            !self.chave_hash.is_empty()
        }

        // Método de autenticação público
        pub fn validar_segredo(&self, tentativa: &[u8]) -> bool {
            let tentativa_mascarada = cifras::aplicar_xor_mask(tentativa, 0x5A);
            self.chave_hash == tentativa_mascarada
        }
    }
}

// 2. Módulo de Rede e Telemetria
mod rede {
    pub mod telemetria {
        pub fn emitir_heartbeat(modulo: &str) {
            println!("  [TELEMETRIA] Módulo '{}' ativo e operando em regime nominal.", modulo);
        }
    }
}

// 3. Importação Limpa com 'use' e caminhos absolutos 'crate::'
use seguranca::CofreCredencial;
use rede::telemetria::emitir_heartbeat;

fn main() {
    println!("=== ARQUITETURA MODULAR E CONTROLE DE VISIBILIDADE ===");

    // 1. Instanciando estrutura com campos privados via construtor público
    let cofre_db = CofreCredencial::novo("DB_PRODUCAO_POSTGRES", b"SenhaUltraSegura#2026");
    println!("Cofre criado para: {}", cofre_db.identificador);

    // 2. Invocando método com visibilidade restrita a crate (pub(crate))
    let integro = cofre_db.verificar_integridade();
    println!("Integridade criptográfica do cofre: {}", integro);

    // 3. Validando segredo via método público
    let tentativa_correta = b"SenhaUltraSegura#2026";
    let tentativa_incorreta = b"123456";
    println!("Tentativa 1 (correta): {}", cofre_db.validar_segredo(tentativa_correta));
    println!("Tentativa 2 (incorreta): {}", cofre_db.validar_segredo(tentativa_incorreta));

    // 4. Invocando função de telemetria importada com 'use'
    emitir_heartbeat("AuthService");
    emitir_heartbeat("DatabasePool");

    // 5. Estrutura de Cargo Workspace (Exemplo de Cargo.toml Monorepo)
    println!("\nEstrutura Canônica de um Cargo Workspace Corporativo:");
    println!("  [workspace]");
    println!("  members = [\"core-engine\", \"api-gateway\", \"cli-tool\"]");
    println!("  resolver = \"2\"");
}

2. Saída Esperada no Terminal

=== ARQUITETURA MODULAR E CONTROLE DE VISIBILIDADE ===
Cofre criado para: DB_PRODUCAO_POSTGRES
Integridade criptográfica do cofre: true
Tentativa 1 (correta): true
Tentativa 2 (incorreta): false
  [TELEMETRIA] Módulo 'AuthService' ativo e operando em regime nominal.
  [TELEMETRIA] Módulo 'DatabasePool' ativo e operando em regime nominal.

Estrutura Canônica de um Cargo Workspace Corporativo:
  [workspace]
  members = ["core-engine", "api-gateway", "cli-tool"]
  resolver = "2"