Hoe veilig te werken met argumenten en enum-varianten in Rust

Het werken met commandoregelargumenten in Rust kan eenvoudig lijken, maar vereist zorgvuldige aandacht voor details. In dit hoofdstuk wordt uitgelegd hoe je gebruik kunt maken van Rust's krachtige type-systeem en externe bibliotheken zoals clap om argumenten veilig te verwerken. De focus ligt op het definiëren van je eigen enum-typen, het implementeren van de vereiste methoden, en het correct valideren van de invoer.

In het voorbeeld wordt een enum EntryType gedefinieerd die drie varianten bevat: Dir, File, en Link. Deze varianten worden gebruikt om te specificeren welk type bestand of directory wordt gezocht. Om deze varianten effectief in te stellen via de commandoregel, moeten we de ValueEnum trait implementeren, die zorgt voor de juiste conversie van enum-waarden naar stringrepresentaties die door clap kunnen worden begrepen.

rust
Copy code
#[derive(Debug, Eq, PartialEq, Clone)]
enum EntryType {
    Dir,
    File,
    Link,
}
impl ValueEnum for EntryType {

    fn value_variants<'a>() -> &'a [Self] {

        &[EntryType::Dir, EntryType::File, EntryType::Link]
    }
    fn to_possible_value<'a>(&self) -> Option<PossibleValue> {
        Some(match self {
            EntryType::Dir => PossibleValue::new("d"),
            EntryType::File => PossibleValue::new("f"),
            EntryType::Link => PossibleValue::new("l"),
        })
    }
}

Het value_variants-methode retourneert de toegestane varianten van de enum, terwijl de to_possible_value-methode een specifieke enum-variant converteert naar een stringrepresentatie (bijvoorbeeld "d" voor Directory, "f" voor File, enzovoort). Wanneer je een ongeldige waarde invoert, zoals --type x, zal het programma een foutmelding genereren en de invoer afwijzen, wat de veiligheid van de argumentverwerking waarborgt.

Bij het toevoegen van argumenten aan je programma kun je gebruik maken van de clap bibliotheek. Dit stelt je in staat om gemakkelijk de verwachte argumenten voor je programma te definiëren, zoals zoekpaden, naamfilters en typefilters. De get_args functie maakt een structuur die de waarden van de argumenten ophaalt:

rust
Copy code
fn get_args() -> Args {

    let matches = Command::new("findr")
        .version("0.1.0")
        .author("Ken Youens-Clark")
        .about("Rust versie van `find`")
        .arg(
            Arg::new("paths")
                .value_name("PATH")
                .help("Zoekpaden")
                .default_value(".")
                .num_args(0..),
        )
        .arg(
            Arg::new("names")
                .value_name("NAME")
                .short('n')
                .long("name")
                .help("Naam")
                .value_parser(Regex::new)
                .action(ArgAction::Append)
                .num_args(0..),
        )
        .arg(
            Arg::new("types")
                .value_name("TYPE")
                .short('t')
                .long("type")
                .help("Type van het bestand")
                .value_parser(clap::value_parser!(EntryType))
                .action(ArgAction::Append)
                .num_args(0..),
        )
        .get_matches();
    Args {
        paths: matches.get_many("paths").unwrap().cloned().collect(),
        names: matches.get_many("names").unwrap_or_default().cloned().collect(),
        entry_types: matches.get_many("types").unwrap_or_default().cloned().collect(),
    }
}

Met deze aanpak kan de gebruiker meerdere zoekpaden, naamfilters en bestandstypen opgeven. Bijvoorbeeld, als de gebruiker --type f opgeeft, zal het programma de bestanden van het type File vinden. Het is belangrijk te begrijpen dat de waarden voor --type beperkt zijn tot specifieke mogelijke waarden: d voor directories, f voor bestanden en l voor symbolische links.

Naast de basisfunctionaliteit voor argumentverwerking is het essentieel om te begrijpen dat reguliere expressies voor naamfilters anders werken dan glob-patterns. Glob-patterns zoals *.txt worden vaak in shellomgevingen gebruikt om bestanden te matchen, maar in reguliere expressies heeft de * operator een andere betekenis en moet de punt (.) worden ontsnapt als \.. Daarom moeten we bij het gebruiken van reguliere expressies in de commandoregel de juiste syntaxis toepassen.

Bijvoorbeeld, om alle bestanden te vinden die eindigen op .txt, zou de gebruiker de volgende opdracht kunnen invoeren:

bash
Copy code
cargo run -- --name .*\.txt

Het gebruik van reguliere expressies stelt het programma in staat om veel flexibeler te zoeken dan met glob-patterns. Dit is bijzonder nuttig wanneer de gebruiker complexe zoekopdrachten wil uitvoeren, zoals het vinden van bestanden met specifieke patronen in hun naam.

Wat betreft de implementatie is het cruciaal om op te merken dat de get_args functie meerdere waarden accepteert voor de argumenten. Dit maakt het mogelijk om bijvoorbeeld meerdere bestandsnamen op te geven of meerdere bestandstypen te zoeken. Het is belangrijk dat deze waarden correct worden verzameld en verwerkt, zodat ze overeenkomen met de verwachtingen van de gebruiker.

Hoe vind je alle bijbehorende items in een directory met opgegeven argumenten?

Bij het ontwikkelen van een programma dat bestanden in directories doorzoekt op basis van gebruikersinvoer, begint het proces met het valideren van de argumenten die de gebruiker heeft opgegeven. Zodra deze argumenten correct zijn, is de volgende stap het daadwerkelijk doorzoeken van de opgegeven paden en het vinden van de gewenste items. Hiervoor gebruiken we de walkdir crate, die een handige manier biedt om door directories te lopen en bestandspaden te verkrijgen.

In de basisstructuur van het programma wordt er vanuit gegaan dat er verschillende argumenten kunnen worden meegegeven, zoals het pad, de naam van bestanden, en het type van de entries die we willen zoeken. Deze argumenten worden verwerkt en vervolgens doorgegeven aan een functie die verantwoordelijk is voor het doorzoeken van de directories en het weergeven van de resultaten.

Een belangrijk aspect is het afhandelen van mogelijke fouten, zoals niet-bestaande directories of onleesbare bestanden. Deze situaties worden netjes afgehandeld door een foutmelding naar de standaard foutuitvoer te sturen, zonder het programma abrupt te laten stoppen. De WalkDir biedt een iterator die elk bestand in de directory retourneert als een Result. Als een fout optreedt, wordt deze weergegeven met een foutmelding. Als de entry correct wordt gevonden, wordt het pad van het bestand afgedrukt.

Bijvoorbeeld, de volgende code toont hoe we door de directories kunnen lopen en alle items kunnen weergeven:

rust
Copy code
fn run(args: Args) -> Result<()> {

    for path in args.paths {
        for entry in WalkDir::new(path) {
            match entry {
                Err(e) => eprintln!("{e}"),

                Ok(entry) => println!("{}", entry.path().display()),

            }
        }
    }
    Ok(())
}

Bij de uitvoering van dit programma wordt elk bestandspad geprint. Dit is een goede eerste stap om de inhoud van een directory weer te geven. Echter, om verder te verfijnen wat we zoeken, kunnen we filters toepassen op basis van de opgegeven argumenten.

Een van de volgende verbeteringen is het filteren op basis van bestandstypes. We kunnen bepalen of we alleen links, directories, of reguliere bestanden willen zien. Dit kan worden bereikt door de entry_types argumenten te gebruiken die door de gebruiker zijn opgegeven. Hiervoor gebruiken we de any functie van iterators in Rust, die kijkt of ten minste één van de opgegeven types overeenkomt met het bestandstype van de entry.

Het volgende voorbeeld laat zien hoe we bestandstypes kunnen filteren:

rust
Copy code
fn run(args: Args) -> Result<()> {
    for path in args.paths {

        for entry in WalkDir::new(path) {

            match entry {
                Err(e) => eprintln!("{e}"),
                Ok(entry) => {
                    if args.entry_types.is_empty() 
                        || args.entry_types.iter().any(|entry_type| {
                            match entry_type {
                                EntryType::Link => entry.file_type().is_symlink(),
                                EntryType::Dir => entry.file_type().is_dir(),
                                EntryType::File => entry.file_type().is_file(),
                            }
                        })
                    {
                        println!("{}", entry.path().display());
                    }
                }
            }
        }
    }
    Ok(())
}

Dit zorgt ervoor dat alleen de items die overeenkomen met de opgegeven types worden weergegeven. Als er geen type is opgegeven, worden alle types getoond.

Verder kunnen we ook filteren op bestandsnamen met behulp van reguliere expressies. Dit kan handig zijn wanneer de gebruiker alleen bestanden wil zien die voldoen aan een specifiek patroon. Net als bij de bestandstypes, gebruiken we de any iterator om te controleren of de naam van het bestand overeenkomt met een van de opgegeven reguliere expressies. Het combineren van deze twee filters (bestandstype en naam) resulteert in een krachtige zoekfunctionaliteit.

Het volgende voorbeeld toont hoe we bestandnamen kunnen filteren op basis van een opgegeven reguliere expressie:

rust
Copy code
fn run(args: Args) -> Result<()> {

    for path in args.paths {
        for entry in WalkDir::new(path) {
            match entry {
                Err(e) => eprintln!("{e}"),
                Ok(entry) => {
                    if (args.entry_types.is_empty() 
                        || args.entry_types.iter().any(|entry_type| {
                            match entry_type {
                                EntryType::Link => entry.file_type().is_symlink(),
                                EntryType::Dir => entry.file_type().is_dir(),
                                EntryType::File => entry.file_type().is_file(),
                            }
                        }))
                        && (args.names.is_empty() 
                            || args.names.iter().any(|re| {

                                re.is_match(&entry.file_name().to_string_lossy())

                            }))
                    {
                        println!("{}", entry.path().display());
                    }
                }
            }
        }
    }
    Ok(())
}

Wanneer dit allemaal samenkomt, ontstaat er een robuust programma dat de gebruiker in staat stelt om door directories te lopen, bestandstypen te filteren, en bestanden op naam te zoeken. Belangrijk om te begrijpen is dat deze aanpak gebaseerd is op een iteratief proces van het controleren van verschillende criteria, waarbij gebruik wordt gemaakt van de mogelijkheden van de WalkDir crate in combinatie met Rust’s krachtige iterator-methoden.

Voor de gebruiker is het belangrijk te begrijpen dat dit programma geen magische oplossing biedt voor alle mogelijke zoekscenario's. Er kunnen altijd scenario's zijn waarin de zoekcriteria te complex zijn of de directorystructuren ongebruikelijk zijn. Toch biedt deze benadering een solide basis voor het bouwen van geavanceerde bestandszoektools.

Hoe je een programma kunt schrijven om inputbestanden te vinden en te lezen met Rust

Het doel van dit programma is om de inputbronnen te vinden, bestanden te lezen en vervolgens een lijst van records te verwerken. Deze records kunnen afkomstig zijn van verschillende bestandslocaties, en het programma moet in staat zijn om alleen de bruikbare bestanden te selecteren, zoals het negeren van binaires die niet nodig zijn.

Om te beginnen, kan de functie find_files worden geschreven. Deze functie neemt een lijst van paden als argumenten en moet alle bestanden in deze paden vinden, ongeacht of ze bestanden of mappen zijn. Wanneer een pad een map is, moeten alle bestanden binnen deze map worden meegenomen. Verder is het belangrijk om te weten dat sommige bestanden, zoals de .dat-bestanden, niet bruikbaar zijn voor dit specifieke programma. Het programma moet in staat zijn om deze te negeren.

Een van de eerste concepten die we tegenkomen in Rust is de structuur Path en zijn eigendomsvorm, PathBuf. Deze structuren helpen ons bij het manipuleren en onderzoeken van bestands- en directorypaden. Terwijl Path voornamelijk wordt gebruikt om padoperaties uit te voeren zonder de eigenaar te zijn van het pad zelf, biedt PathBuf een eigendomsversie van deze structuur die je kunt wijzigen en beheren. Wanneer je een functie schrijft die paden retourneert, moet je dus altijd PathBuf gebruiken om geheugenfouten te vermijden en de code robuuster te maken.

Het is belangrijk om te benadrukken dat je de foutbehandeling niet moet negeren. Wanneer een niet-bestaand bestand of een onleesbaar bestand wordt aangetroffen, moet het programma een foutmelding geven en stoppen, zoals je ook zou verwachten van een programma dat met belangrijke gegevens werkt. Dit voorkomt onvoorziene gevolgen bij de verwerking van gegevens.

De functie find_files kan er als volgt uitzien:

rust
Copy code
use std::path::{Path, PathBuf};

fn find_files(paths: &[String]) -> Result<Vec<PathBuf>, std::io::Error> {
    let mut files = Vec::new();
    for path in paths {
        let path = Path::new(path);
        if path.is_dir() {
            // Verwerk bestanden in de directory

            for entry in std::fs::read_dir(path)? {

                let entry = entry?;
                let entry_path = entry.path();
                if entry_path.extension().map_or(true, |ext| ext != "dat") {
                    files.push(entry_path);
                }
            }
        } else if path.is_file() {

            if path.extension().map_or(true, |ext| ext != "dat") {

                files.push(path.to_path_buf());
            }
        }
    }
    files.sort();
    files.dedup();
    Ok(files)
}

Deze functie zoekt door een lijst van opgegeven paden en haalt alle bruikbare bestanden op, waarbij het .dat-bestanden negeert. De resultaten worden gesorteerd en dubbele paden worden verwijderd.

Bij het testen van deze functie moet je controleren of de bestanden daadwerkelijk worden gevonden en correct worden weergegeven. Dit kan worden gedaan door een eenheidstest die zowel de succesvolle gevallen als de fouten afhandelt, bijvoorbeeld wanneer een pad niet bestaat of wanneer toegang tot een bestand wordt geweigerd.

De Fortune-struct kan als volgt worden gedefinieerd:

rust
Copy code
#[derive(Debug)]
struct Fortune {
    source: String,
    text: String,
}

Deze struct houdt de naam van de bron bij (d.w.z. het pad naar het bestand) en de tekst die in het bestand wordt aangetroffen, tot het percentage-teken %, dat het einde van een record markeert. De read_fortunes functie kan er als volgt uitzien:

rust
Copy code
fn read_fortunes(paths: &[PathBuf]) -> Result<Vec<Fortune>, std::io::Error> {

    let mut fortunes = Vec::new();
    for path in paths {
        let content = std::fs::read_to_string(path)?;
        let parts: Vec<&str> = content.split('%').collect();

        if let Some(text) = parts.get(0) {

            fortunes.push(Fortune {
                source: path.display().to_string(),
                text: text.to_string(),
            });
        }
    }
    Ok(fortunes)
}

Met deze aanpak kun je efficiënt omgaan met bestandssystemen, verschillende besturingssystemen ondersteunen en de bestandsverwerking grondig testen.

Bij het ontwikkelen van programma's die bestandsverwerking uitvoeren, is het belangrijk om altijd na te denken over foutafhandelingsmechanismen. Rust biedt krachtige hulpmiddelen zoals Result en Option om robuuste foutbehandeling te implementeren. Je moet ervoor zorgen dat je alle mogelijke foutscenario’s afdekt, zoals niet-bestaande bestanden, onleesbare bestanden of verkeerde bestandsindelingen. Alleen zo kun je er zeker van zijn dat je programma onder alle omstandigheden goed werkt.

Hoe belangrijk is het juiste exit-status in command-line programma's?

In elke programmeertaal en elk besturingssysteem zijn de manier waarop programma's communiceren met hun omgeving en de effectiviteit van hun samenwerking essentieel voor het ontwikkelen van betrouwbare software. Eén belangrijk aspect hiervan is de exit-status van programma’s, een concept dat onmisbaar is bij het schrijven van goed gedragen command-line tools. Dit onderwerp is belangrijk omdat de exit-status ervoor zorgt dat programma's correct kunnen samenwerken in een keten van processen, wat cruciaal is voor het creëren van composable software.

In Unix-achtige omgevingen, waar de kracht van de command-line vaak wordt benut om verschillende kleine programma's te combineren, kan een programma dat geen juiste exit-status doorgeeft leiden tot onverwachte en potentieel gevaarlijke resultaten. Het is niet alleen belangrijk voor een programma om goed te functioneren, maar ook om zijn status te communiceren naar andere programma’s die mogelijk afhankelijk zijn van deze status om te bepalen of de volgende stappen uitgevoerd kunnen worden.

Een eenvoudige manier om dit te illustreren is met de gebruikelijke bash operator &&. Deze operator zorgt ervoor dat een tweede commando alleen wordt uitgevoerd als het eerste commando succesvol is. Zo kan men bijvoorbeeld twee commando’s combineren:

shell
Copy code
$ true && ls
Cargo.lock  Cargo.toml  src/  target/  tests/

Hier wordt ls alleen uitgevoerd als true succesvol is. Als we echter een mislukking introduceren, bijvoorbeeld door false te gebruiken in plaats van true, wordt de tweede opdracht niet uitgevoerd:

shell
Copy code
$ false && ls

$ echo $?
1

In dit geval resulteert de mislukking van het eerste commando (false) in een exit-status van 1, wat aangeeft dat er een fout is opgetreden. Dit soort gedrag is niet alleen belangrijk om de integriteit van de workflow te bewaren, maar is ook essentieel in een omgeving waarin verschillende programma's op elkaar vertrouwen en de resultaten van vorige commando's gebruiken om hun eigen acties te bepalen.

In Rust, bijvoorbeeld, is het mogelijk om de exit-status van een programma expliciet in te stellen met behulp van de std::process::exit functie, die het programma laat eindigen met een specifieke exit-code. Dit is belangrijk, omdat Rust, net als veel andere moderne talen, veiligheid en controle over procesbeheer hoog in het vaandel heeft staan.

Naast het beheersen van de exit-status is het ook belangrijk om een solide teststructuur te hebben. In een goed opgezet Rust-project bijvoorbeeld wordt de testlogica gescheiden van de hoofdcode, wat de organisatie en onderhoudbaarheid van de code ten goede komt. Door gebruik te maken van crates en het correct configureren van testdirectories kunnen ontwikkelaars ervoor zorgen dat hun programma's niet alleen de juiste functionaliteit bieden, maar ook betrouwbaar zijn in termen van foutafhandeling en exit-status.

Met tools als Cargo, het build-systeem voor Rust, kunnen ontwikkelaars eenvoudig nieuwe projecten aanmaken, code compileren en uitvoeren, en zelfs specifieke uitvoerbare bestanden testen. Cargo maakt het ook mogelijk om alternatieve binaire bestanden in een project te creëren door eenvoudigweg extra bronbestanden toe te voegen in de src/bin directory, wat de modulariteit van het project verder vergroot.

Ten slotte moet elke ontwikkelaar zich realiseren dat, hoewel het gemakkelijk is om door de basisfunctionaliteit van een programma heen te kijken, het garanderen van de juiste exit-status en foutafhandelingsmechanismen een fundament zijn voor het bouwen van betrouwbare en interoperabele tools. Het succes van een programma hangt niet alleen af van wat het doet, maar ook van hoe goed het zich gedraagt in de grotere context van een systeem van programma's.