Rust niveau 5 — Traits, génériques et tests

use std::fmt;

trait Equipement {
    fn nom(&self) -> String;
    fn consommation_watts(&self) -> u32;

    fn cout_annuel(&self, heures_par_jour: u32, prix_kwh: f64) -> f64 {
        let kwh = self.consommation_watts() as f64 * heures_par_jour as f64 * 365.0 / 1000.0;
        kwh * prix_kwh
    }
}

struct Poste { nom: String }
struct Ecran { pouces: u32 }
struct Switch { ports: u32 }

impl Equipement for Poste {
    fn nom(&self) -> String { format!("poste {}", self.nom) }
    fn consommation_watts(&self) -> u32 { 65 }
}
impl Equipement for Ecran {
    fn nom(&self) -> String { format!("écran {}\"", self.pouces) }
    fn consommation_watts(&self) -> u32 { if self.pouces > 24 { 30 } else { 20 } }
}
impl Equipement for Switch {
    fn nom(&self) -> String { format!("switch {} ports", self.ports) }
    fn consommation_watts(&self) -> u32 { 5 + self.ports }
}

impl fmt::Display for Poste {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Poste<{}>", self.nom)
    }
}

fn inventaire<T: fmt::Display>(liste: &[T]) {
    for e in liste {
        println!("- {e}");
    }
}

fn main() {
    let salle: Vec<Box<dyn Equipement>> = vec![
        Box::new(Poste { nom: String::from("PC-01") }),
        Box::new(Poste { nom: String::from("PC-02") }),
        Box::new(Ecran { pouces: 27 }),
        Box::new(Ecran { pouces: 22 }),
        Box::new(Switch { ports: 24 }),
    ];
    let mut total = 0.0;
    for e in &salle {
        let c = e.cout_annuel(8, 0.25);
        total += c;
        println!("{:<18} {:>4} W {:>8.2} €", e.nom(), e.consommation_watts(), c);
    }
    println!("{:<25} {:>8.2} €", "Total", total);

    inventaire(&[Poste { nom: String::from("PC-01") }, Poste { nom: String::from("PC-02") }]);
}

Explication

La méthode par défaut cout_annuel s’appuie sur consommation_watts, que chaque type fournit : le calcul n’existe qu’en un seul exemplaire. Vec<Box<dyn Equipement>> range dans une même liste des types différents ; inventaire, générique, accepte une liste de n’importe quel type affichable.

fn main() {
    let mots = vec!["serveur", "Pare-feu", "routeur", "", "switch", "VLAN", "proxy"];

    let non_vides = mots.iter().filter(|m| !m.is_empty()).count();

    let mut minuscules: Vec<String> = mots
        .iter()
        .filter(|m| !m.is_empty())
        .map(|m| m.to_lowercase())
        .collect();
    minuscules.sort();

    let plus_long = mots.iter().max_by_key(|m| m.chars().count());

    let total: usize = mots
        .iter()
        .map(|m| m.chars().count())
        .filter(|&n| n > 5)
        .sum();

    let initiales: String = mots
        .iter()
        .filter_map(|m| m.chars().next())
        .map(|c| c.to_ascii_uppercase())
        .collect();

    println!("{non_vides}\n{minuscules:?}\n{plus_long:?}\n{total}\n{initiales}");
}

Explication

filter_map combine un filtre et une transformation : chars().next() renvoie None pour le mot vide, qui est ainsi éliminé. collect() sait fabriquer une String à partir de caractères. max_by_key renvoie le dernier maximum en cas d’égalité : « serveur », « routeur » et « Pare-feu » ont tous 7 ou 8 caractères, vérifie lequel sort.

fn sans_accent(c: char) -> char {
    match c {
        'à' | 'â' | 'ä' => 'a',
        'é' | 'è' | 'ê' | 'ë' => 'e',
        'î' | 'ï' => 'i',
        'ô' | 'ö' => 'o',
        'ù' | 'û' | 'ü' => 'u',
        'ç' => 'c',
        'ÿ' => 'y',
        autre => autre,
    }
}

pub fn identifiant(prenom: &str, nom: &str) -> Option<String> {
    let initiale = prenom.trim().chars().next()?;
    let brut: String = std::iter::once(initiale)
        .chain(nom.chars())
        .flat_map(|c| c.to_lowercase())
        .map(sans_accent)
        .filter(|c| c.is_ascii_lowercase() || c.is_ascii_digit())
        .take(20)
        .collect();
    if brut.is_empty() { None } else { Some(brut) }
}

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

    #[test] fn cas_simple() { assert_eq!(identifiant("Lina", "Martin"), Some("lmartin".into())); }
    #[test] fn accents() { assert_eq!(identifiant("Élodie", "Brûlé"), Some("ebrule".into())); }
    #[test] fn nom_compose() { assert_eq!(identifiant("Jean", "Le Goff-Durand"), Some("jlegoffdurand".into())); }
    #[test] fn apostrophe() { assert_eq!(identifiant("Sean", "O'Neil"), Some("soneil".into())); }
    #[test] fn cedille() { assert_eq!(identifiant("François", "Garçon"), Some("fgarcon".into())); }
    #[test] fn troncature() { assert_eq!(identifiant("A", "Abcdefghijklmnopqrstuvwxyz").map(|s| s.len()), Some(20)); }
    #[test] fn prenom_vide() { assert_eq!(identifiant("", "Martin"), None); }
    #[test] fn que_des_symboles() { assert_eq!(identifiant("-", "!!"), None); }
    #[test] fn espaces_autour() { assert_eq!(identifiant("  Sam ", " Noël"), Some("snoel".into())); }
}

fn main() {
    println!("{:?}", identifiant("Élodie", "Le Brûlé"));
}

Explication

std::iter::once(initiale).chain(nom.chars()) construit un flux « initiale puis nom » sans créer de texte intermédiaire. to_lowercase() renvoie un itérateur (certains caractères deviennent plusieurs lettres), d’où flat_map. Le filtre final ne garde que les lettres ASCII minuscules et les chiffres : c’est une liste blanche, plus sûre qu’une liste de caractères interdits.

Pour aller plus loin

La bibliothèque unicode-normalization gère tous les accents de façon exhaustive ; notre match couvre le français courant.

mod politique {
    pub trait Regle {
        fn verifier(&self, mdp: &str) -> Result<(), String>;
    }

    pub struct LongueurMin(pub usize);
    pub struct Majuscule;
    pub struct Minuscule;
    pub struct Chiffre;
    pub struct Special;
    pub struct PasDansListe(pub Vec<&'static str>);

    impl Regle for LongueurMin {
        fn verifier(&self, mdp: &str) -> Result<(), String> {
            let n = mdp.chars().count();
            if n >= self.0 { Ok(()) } else { Err(format!("au moins {} caractères ({n} actuellement)", self.0)) }
        }
    }
    impl Regle for Majuscule {
        fn verifier(&self, mdp: &str) -> Result<(), String> {
            if mdp.chars().any(|c| c.is_uppercase()) { Ok(()) } else { Err("une majuscule".into()) }
        }
    }
    impl Regle for Minuscule {
        fn verifier(&self, mdp: &str) -> Result<(), String> {
            if mdp.chars().any(|c| c.is_lowercase()) { Ok(()) } else { Err("une minuscule".into()) }
        }
    }
    impl Regle for Chiffre {
        fn verifier(&self, mdp: &str) -> Result<(), String> {
            if mdp.chars().any(|c| c.is_ascii_digit()) { Ok(()) } else { Err("un chiffre".into()) }
        }
    }
    impl Regle for Special {
        fn verifier(&self, mdp: &str) -> Result<(), String> {
            if mdp.chars().any(|c| !c.is_alphanumeric() && !c.is_whitespace()) {
                Ok(())
            } else {
                Err("un caractère spécial".into())
            }
        }
    }
    impl Regle for PasDansListe {
        fn verifier(&self, mdp: &str) -> Result<(), String> {
            let m = mdp.to_lowercase();
            if self.0.iter().any(|interdit| *interdit == m) {
                Err("mot de passe trop courant".into())
            } else {
                Ok(())
            }
        }
    }

    pub struct Politique {
        regles: Vec<Box<dyn Regle>>,
    }

    impl Politique {
        pub fn new() -> Self { Politique { regles: Vec::new() } }

        pub fn ajouter(mut self, r: impl Regle + 'static) -> Self {
            self.regles.push(Box::new(r));
            self
        }

        pub fn standard() -> Self {
            Politique::new()
                .ajouter(LongueurMin(12))
                .ajouter(Majuscule)
                .ajouter(Minuscule)
                .ajouter(Chiffre)
                .ajouter(Special)
                .ajouter(PasDansListe(vec!["azerty", "motdepasse", "123456", "password", "azertyuiop123!"]))
        }

        pub fn controler(&self, mdp: &str) -> Vec<String> {
            self.regles.iter().filter_map(|r| r.verifier(mdp).err()).collect()
        }
    }
}

use politique::Politique;

fn main() {
    let p = Politique::standard();
    for mdp in ["azerty", "Soleil-2026-Angers", "tropcourt1!A"] {
        let erreurs = p.controler(mdp);
        if erreurs.is_empty() {
            println!("{mdp:<22} accepté");
        } else {
            println!("{mdp:<22} refusé : {}", erreurs.join(", "));
        }
    }
}

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

    fn p() -> Politique { Politique::standard() }

    #[test] fn valide() { assert!(p().controler("Soleil-2026-Angers").is_empty()); }
    #[test] fn trop_court() { assert_eq!(p().controler("Ab1!efghijk").len(), 1); }
    #[test] fn sans_majuscule() { assert_eq!(p().controler("soleil-2026-angers"), vec!["une majuscule"]); }
    #[test] fn sans_minuscule() { assert_eq!(p().controler("SOLEIL-2026-ANGERS"), vec!["une minuscule"]); }
    #[test] fn sans_chiffre() { assert_eq!(p().controler("Soleil-deux-Angers"), vec!["un chiffre"]); }
    #[test] fn sans_special() { assert_eq!(p().controler("Soleil2026Angers"), vec!["un caractère spécial"]); }
    #[test] fn courant_casse_ignoree() {
        assert!(p().controler("AZERTYUIOP123!").contains(&"mot de passe trop courant".to_string()));
    }
    #[test] fn vide() { assert!(p().controler("").len() >= 5); }
    #[test] fn espaces_ne_sont_pas_speciaux() { assert!(p().controler("Soleil 2026 Angers").contains(&"un caractère spécial".to_string())); }
    #[test] fn unicode_compte_en_caracteres() { assert!(p().controler("Éléphant-2026").is_empty()); }
    #[test] fn politique_sur_mesure() {
        let courte = Politique::new().ajouter(LongueurMin(4));
        assert!(courte.controler("abcd").is_empty());
    }
}

Explication

Chaque règle est un petit type indépendant ; Politique ne connaît que le trait Regle. Ajouter une règle, c’est ajouter un type, sans toucher au reste : c’est le principe ouvert-fermé. La méthode ajouter prend et renvoie self, ce qui permet d’enchaîner les appels. filter_map(|r| r.verifier(mdp).err()) collecte seulement les erreurs.

Pour aller plus loin

En production, la liste des mots de passe courants contient des centaines de milliers d’entrées, issues de fuites réelles. On la charge depuis un fichier dans un HashSet pour une recherche instantanée.