Hoe werk je met commandoregelargumenten in Rust voor een "cat"-achtige applicatie?

In Rust is het verwerken van commandoregelargumenten een essentieel onderdeel van veel applicaties. De manier waarop deze argumenten worden gedefinieerd en verwerkt, bepaalt de functionaliteit van het programma. Dit geldt ook voor de implementatie van een programma dat een eenvoudige versie van de cat-opdracht in Unix nabootst, met de mogelijkheid om bestandsinhoud weer te geven met of zonder regelnummering.

Een van de kerncomponenten in dit proces is het definiëren van de structuur voor de argumenten. De structuur die we hier behandelen heet Args. Deze bevat drie velden: files, number_lines en number_nonblank_lines. De files is een vector van bestandsnamen die moet worden weergegeven, terwijl de andere twee booleaanse waarden bepalen of regelnummering moet worden toegepast en of nummering alleen voor niet-lege regels moet plaatsvinden.

De struct Args wordt gedefinieerd als volgt:

rust
Copy code
struct Args {

    files: Vec<String>,
    number_lines: bool,
    number_nonblank_lines: bool,
}

De files is een vector die de namen van de bestanden bevat die moeten worden verwerkt. De booleaanse variabelen number_lines en number_nonblank_lines geven aan of het programma lijnnummers moet afdrukken, respectievelijk voor alle regels of alleen voor de niet-lege regels.

Wanneer je met clap werkt, kun je verschillende manieren gebruiken om argumenten in te voeren. Een veelgebruikte benadering is de derive-macro, zoals in het volgende voorbeeld:

rust
Copy code
use clap::Parser;
#[derive(Debug, Parser)]
#[command(author, version, about)]
/// Rust versie van `cat`
struct Args {
    /// Invoerverbestanden
    #[arg(value_name = "FILE", default_value = "-")]
    files: Vec<String>,
    /// Nummer regels
    #[arg(short('n'), long("number"), conflicts_with("number_nonblank_lines"))]
    number_lines: bool,
    /// Nummer niet-lege regels
    #[arg(short('b'), long("number-nonblank"))]
    number_nonblank_lines: bool,
}

Commandoregelparseren met clap

Als je de clap-derive-macro gebruikt, kun je eenvoudig een programma bouwen waarin de argumenten automatisch worden verwerkt. De Args::parse() methode wordt opgeroepen in de main functie om de argumenten te verkrijgen:

rust
Copy code
fn main() {
    let args = Args::parse();
    println!("{args:#?}");
}

Wanneer het programma wordt uitgevoerd met de --help vlag, zal het een gebruikshelp weergeven:

bash
Copy code
$ cargo run -- --help

Rust versie van `cat`
Usage: catr [OPTIONS] [FILE]...
Arguments:
  [FILE]...  Invoerbestand(en) [standaard: -]
Options:
  -n, --number           Nummer regels
  -b, --number-nonblank  Nummer niet-lege regels
  -h, --help             Print help
  -V, --version          Print version

Zonder argumenten, wordt een standaardoutput weergegeven:

bash
Copy code
$ cargo run
Args {
    files: ["-"],
    number_lines: false,
    number_nonblank_lines: false,
}

Wanneer specifieke argumenten worden ingevoerd, zoals -n, worden de bijbehorende velden in de structuur aangepast:

bash
Copy code
$ cargo run -- -n tests/inputs/fox.txt

Args {
    files: ["tests/inputs/fox.txt"],
    number_lines: true,
    number_nonblank_lines: false,
}

Conflicten tussen argumenten

Een belangrijk punt bij het werken met commandoregelargumenten is het omgaan met conflicterende opties. In dit geval kunnen de opties -n (nummer alle regels) en -b (nummer alleen niet-lege regels) niet samen worden gebruikt. Dit wordt gecontroleerd via de conflicts_with annotatie in clap:

rust
Copy code
.arg(Arg::new("number")

    .short('n')
    .long("number")
    .help("Nummer regels")
    .action(ArgAction::SetTrue)
    .conflicts_with("number_nonblank"))

Wanneer beide opties tegelijkertijd worden opgegeven, geeft het programma een foutmelding:

bash
Copy code
$ cargo run -- -b -n tests/inputs/fox.txt
error: the argument '--number-nonblank' cannot be used with '--number'
Usage: catr --number-nonblank ...

Bestanden verwerken

Bijvoorbeeld:

rust
Copy code
fn run(args: Args) -> Result<()> {
    for filename in args.files {
        println!("{filename}");
    }
    Ok(())
}

Bij het uitvoeren van het programma kan dit bijvoorbeeld de bestandsnamen afdrukken:

bash
Copy code
$ cargo run -- tests/inputs/*.txt tests/inputs/empty.txt

Wat is verder belangrijk?

Bij het ontwerpen van een programma dat gebruikmaakt van commandoregelargumenten, moet je zorgvuldig rekening houden met de verwachte invoer. Het is belangrijk dat het programma robuust is, zodat het in staat is om foutieve of ontbrekende argumenten correct te verwerken. Daarnaast moet je ervoor zorgen dat de logica voor het verwerken van de bestanden efficiënt is en dat het programma in staat is om fouten correct af te handelen, bijvoorbeeld wanneer een bestand niet kan worden geopend.

Hoe kan ik bestanden openen en lezen in Rust met foutafhandeling?

In Rust is het openen en lezen van bestanden een essentiële taak bij het werken met externe gegevens. Het proces is eenvoudig, maar kan snel complex worden, vooral wanneer je te maken hebt met verschillende soorten invoerbronnen, zoals bestanden, standaardinvoer (STDIN) en mogelijk zelfs netwerkbronnen. De manier waarop je dit aanpakt, heeft niet alleen te maken met het lezen van data, maar ook met robuuste foutafhandeling en flexibiliteit.

Het openen van een bestand begint vaak met het achterhalen van de juiste bron: is het bestand op de schijf, of is de invoer afkomstig van de standaardinvoer? De juiste aanpak kan verschillen afhankelijk van de situatie. In Rust kun je gebruik maken van de std::fs::File en std::io::{self, BufRead, BufReader} om bestanden en de standaardinvoer te openen en in te lezen. Deze benaderingen zijn vooral krachtig omdat ze kunnen omgaan met verschillende soorten fouten en de code zeer flexibel maken.

Om te begrijpen hoe je een bestand opent, kun je de volgende functie gebruiken. Deze maakt gebruik van het match-statement, vergelijkbaar met een switch-statement in C, om te bepalen of het bestand dat geopend moet worden een echte bestandsnaam is of de standaardinvoer (aangeduid door een enkel streepje "-").

rust
Copy code
fn open(filename: &str) -> Result<Box<dyn BufRead>> {

    match filename {
        "-" => Ok(Box::new(BufReader::new(io::stdin()))),
        _ => Ok(Box::new(BufReader::new(File::open(filename)?))),
    }
}

Deze functie accepteert een bestandsnaam als parameter en opent het bestand als het een geldige naam is, of leest van STDIN als het een streepje is. Dit gebruik van BufReader maakt het mogelijk om de inhoud regel voor regel te lezen. De functie retourneert een resultaat (Result), wat betekent dat je de mogelijkheid hebt om fouten af te handelen als het bestand niet kan worden geopend.

Je kunt zien dat de bovenstaande functie handig is voor veel scenario's, zoals het openen van bestanden of het lezen van gegevens van STDIN. Deze aanpak laat ook ruimte voor uitbreiding naar andere invoerbronnen, bijvoorbeeld netwerkverbindingen of externe API's, zolang deze de BufRead-trait implementeren.

Het openen van bestanden in Rust gaat vaak gepaard met het afhandelen van verschillende soorten fouten. Bijvoorbeeld, wat moet er gebeuren als het bestand niet bestaat, of als er geen leesrechten zijn? De bovenstaande code is ontworpen om deze scenario's af te handelen, wat resulteert in foutmeldingen die gebruikers duidelijk informeren over wat er misgaat. Zo krijg je bijvoorbeeld de foutmelding "No such file or directory" als een bestand niet bestaat, of "Permission denied" als je probeert een bestand te openen zonder de juiste machtigingen.

Daarnaast is het van belang om te weten hoe je omgaat met verschillende soorten invoer. Wanneer een bestand meerdere regels bevat, is het handig om te leren hoe je deze regels kunt nummeren. Met de toevoeging van de -n vlag kan een programma bijvoorbeeld automatisch de regels nummeren terwijl ze worden afgedrukt. Dit is erg handig wanneer je grote hoeveelheden tekst hebt en snel wilt weten waar je naar kijkt.

Evenzo kun je met de -b vlag lege regels overslaan bij het nummeren. Dit is een veelgebruikte functie bij het verwerken van tekstbestanden waarbij lege regels geen waarde hebben in de weergave van de inhoud.

Voorbeeld van invoer met -n en -b:

arduino
Copy code
cargo run -- -n tests/inputs/spiders.txt

De uitvoer zou er dan als volgt uitzien:

rust
Copy code
1   Don't worry, spiders,
2   I keep house
3   casually.

Bijvoorbeeld:

arduino
Copy code
cargo run -- blargh cant-touch-this tests/inputs/fox.txt

De verwachte uitvoer zou er als volgt uitzien:

lua
Copy code
Failed to open blargh: No such file or directory (os error 2)

Failed to open cant-touch-this: Permission denied (os error 13)
Opened tests/inputs/fox.txt

Het is essentieel om tests in je code op te nemen om te controleren of alles naar behoren werkt. Door regelmatig tests uit te voeren, kun je er zeker van zijn dat je programma goed omgaat met een breed scala aan bestandsinvoer en foutscenario's. Het gebruik van de anyhow::Result voor foutafhandeling, samen met hulpmiddelen zoals assert_cmd::Command en pretty_assertions::assert_eq, maakt het eenvoudig om gedetailleerde tests te schrijven en je programma robuust te houden.

Hoe een willekeurige bestandsnaam genereren en een programma testen in Rust

In Rust is het genereren van een willekeurige bestandsnaam die nog niet bestaat, een interessante uitdaging die de kern raakt van zowel geheugenbeheer als foutafhandelingsmechanismen binnen het besturingssysteem. De functie die we hiervoor gebruiken, heeft de volgende structuur:

rust
Copy code
fn gen_bad_file() -> String {

    loop {
        let filename: String = rand::thread_rng()
            .sample_iter(&Alphanumeric)
            .take(7)
            .map(char::from)
            .collect();
        if fs::metadata(&filename).is_err() {
            return filename;
        }
    }
}

Wat gebeurt er hier precies? De functie gen_bad_file draait een oneindige lus die telkens een willekeurige reeks van zeven alfanumerieke tekens genereert. Deze reeks wordt vervolgens gecontroleerd door de fs::metadata functie. Als de bestandsnaam niet bestaat (wat wordt aangegeven door een foutmelding), wordt de gegenereerde naam geretourneerd. De keuze van zeven tekens is arbitrair, maar biedt voldoende waarschijnlijkheid dat de gegenereerde naam uniek is, vooral als je ervan uitgaat dat de bestandssystemen van moderne besturingssystemen relatief veel bestanden bevatten.

go
Copy code
error[E0382]: use of moved value: `filename`

Dit gebeurt omdat de waarde van filename, als een type String, niet kopieerbaar is zonder expliciete aanwijzing. Het bezitten van de waarde (en het verplaatsen ervan) leidt er toe dat de bestandsnaam niet meer beschikbaar is na de aanroep van fs::metadata. Dit is een fundamenteel principe van het eigendomssysteem van Rust, dat zorgt voor geheugenveiligheid zonder een garbage collector.

Een aanvullende functie, run, biedt een abstractie voor het uitvoeren van programma’s met argumenten en het vergelijken van de uitvoer met een verwachte output. Deze testfunctie controleert niet alleen of het programma succesvol draait, maar of de output exact overeenkomt met de verwachte output:

rust
Copy code
fn run(args: &[&str], expected_file: &str) -> Result<()> {

    let expected = fs::read_to_string(expected_file)?;
    let output = Command::cargo_bin(PRG)?
        .args(args)
        .output()
        .unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).expect("invalid UTF-8");
    assert_eq!(stdout, expected);
    Ok(())
}

Het gebruik van de Command::cargo_bin stelt ons in staat om de gecompileerde versie van een programma uit te voeren, terwijl we tegelijkertijd de uitvoer controleren tegen wat we verwachten. Dit helpt bij het verifiëren van de functionaliteit van het programma door middel van geautomatiseerde tests.

Evenzo, de functie run_stdin biedt de mogelijkheid om tekst via de standaardinvoer (STDIN) aan het programma door te geven. Dit is cruciaal voor het testen van programma’s die gegevens ontvangen via de terminal of andere invoermechanismen:

rust
Copy code
fn run_stdin(input_file: &str, args: &[&str], expected_file: &str) -> Result<()> {

    let input = fs::read_to_string(input_file)?;
    let expected = fs::read_to_string(expected_file)?;
    let output = Command::cargo_bin(PRG)?
        .write_stdin(input)
        .args(args)
        .output()
        .unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).expect("invalid UTF-8");
    assert_eq!(stdout, expected);
    Ok(())
}

Deze functie maakt het mogelijk om inhoud uit een bestand te lezen en deze als invoer naar het programma te sturen, waarbij we wederom de uitvoer verifiëren tegen een verwachte waarde. Dit zorgt voor een strikte controle over de werking van het programma bij verschillende vormen van input.

Tot slot, de verwerking van bestandsinvoer en -uitvoer speelt een belangrijke rol in veel programma’s, vooral bij het werken met tekstbestanden. Rust’s I/O-systeem biedt een robuuste manier om gegevens veilig en efficiënt te verwerken. In de functie run wordt bijvoorbeeld de invoer van een bestand gelezen, de regels worden doorlopen en afgedrukt, terwijl foutafhandelingsmechanismen garanderen dat eventuele problemen bij het openen van een bestand op een gecontroleerde manier worden afgehandeld.

Het begrip van de functies en mechanismen die in deze code worden gepresenteerd is essentieel voor het bouwen van betrouwbare, fouttolerante programma’s die werken met bestanden en externe invoer. Het is belangrijk om te begrijpen hoe Rust's geheugenbeheersysteem en de eigendomsregels van invloed zijn op de manier waarop variabelen worden beheerd, vooral wanneer ze worden doorgegeven tussen functies of wanneer ze worden verplaatst.

Hoe om te gaan met UTF-8 en Geheugenbeheer in Rust

In Rust is het belangrijk om te zorgen voor correcte verwerking van tekstbestanden, vooral wanneer je werkt met UTF-8 gecodeerde strings. Het beheren van geheugen en het werken met bestanden vereist zorgvuldige keuzes om fouten zoals geheugencapaciteitsproblemen of onverwachte crashes te voorkomen.

Wanneer je bestanden in Rust leest, kun je tegen problemen aanlopen als je probeert te werken met strings die geen geldige UTF-8 zijn. Dit kan gebeuren omdat Rust's String-type altijd geldige UTF-8 vereist. De functie String::from_utf8 zal alleen een succesvolle Ok waarde retourneren als de byte-reeks correct is gecodeerd. Echter, als er ongeldige UTF-8-sequenties zijn, kan de functie String::from_utf8_lossy uitkomst bieden door ongeldige sequenties te vervangen door een onbekend teken (meestal de vervangingskarakter: �).

rust
Copy code
let mut contents = String::new();
file.read_to_string(&mut contents)?; // Gevaarlijk!
let bytes = contents.as_bytes();
print!("{}", String::from_utf8_lossy(&bytes[..num_bytes as usize])); // Nog meer gevaar

Een veiligere manier om een beperkt aantal bytes te lezen, kan er als volgt uitzien:

rust
Copy code
let bytes: Result<Vec<u8>, _> = file.bytes().take(num_bytes as usize).collect();

print!("{}", String::from_utf8_lossy(&bytes?));

In dit voorbeeld maken we gebruik van de bytes() methode die de bytes van het bestand in een iterator verwerkt, en gebruiken we take(num_bytes) om alleen het aantal gewenste bytes te lezen. Dit voorkomt onbedoelde geheugenproblemen doordat we het bestand niet volledig in het geheugen laden.

rust
Copy code
error[E0277]: the size for values of type `[u8]` cannot be known at compilation time

Dit kan worden opgelost door gebruik te maken van de juiste type-aanduiding, bijvoorbeeld door expliciet een Vec<u8> te gebruiken, wat een slimme pointer is naar heap-geheugen.

Een ander belangrijk concept is het gebruik van de underscore (_) in type-aanduidingen. In Rust is de underscore een aanwijzing voor de compiler om de type-inferentie over te laten aan de compiler, wat handig kan zijn voor het vereenvoudigen van code.

Met de juiste aanpak en type-aanduiding kun je de meeste foutmeldingen voorkomen en de code leesbaar en veilig houden.

rust
Copy code
for (file_num, filename) in args.files.iter().enumerate() {
    if num_files > 1 {
        println!("{}==> {} <==", if file_num > 0 { "\n" } else { "" }, filename);
    }
}

Deze benadering zorgt ervoor dat bij het verwerken van meerdere bestanden, de bestandsnamen correct worden weergegeven, met een nieuwe regel tussen de bestanden voor visuele scheiding.

Wanneer je verder gaat met het ontwikkelen van dergelijke programma's, kun je overwegen om meer geavanceerde functionaliteit toe te voegen, zoals het verwerken van numerieke waarden met suffixen, zoals 1K voor 1024 bytes, of het verwerken van negatieve waarden zoals -n=-3 om alle regels behalve de laatste drie weer te geven. Dit zou betekenen dat je zowel de bytes als regels moet kunnen behandelen als ondertekende gehele getallen. Daarnaast zou je een optie kunnen toevoegen om niet alleen bytes, maar ook karakters te selecteren, wat een fijnere controle over de inhoud van een bestand zou bieden.

Hoe Bestanden en Mappen te Verwerken met Rust: Een Diepgaande Analyse van Bestandspermissies en Structuur

In Rust kunnen we met behulp van de std::fs module en andere hulpmiddelen krachtige functionaliteit voor het werken met bestanden en mappen implementeren. In dit artikel duiken we diep in de manier waarop bestandsmetadata wordt behandeld, hoe we bestanden kunnen inspecteren en hoe we bestandspermissies op een geavanceerde manier kunnen formatteren en presenteren.

rust
Copy code
let is_hidden = path.file_name().map_or(false, |file_name| {
    file_name.to_string_lossy().starts_with('.')
});
if !is_hidden || show_hidden {
    results.push(entry.path());
}

Na het ophalen van de padlocaties, wordt de metadata van elk bestand bekeken om te bepalen of het bestand een directory is. Voor directories gebruiken we fs::read_dir om de inhoud van de directory te lezen, en voor bestanden verzamelen we direct de noodzakelijke informatie.

Een belangrijk aspect bij het werken met bestanden is het begrijpen van de toegangspermissies. In Linux- en Unix-achtige systemen worden deze permissies opgeslagen als een 9-bits octale waarde die de lees-, schrijf- en uitvoerrechten voor de eigenaar, de groep en anderen definieert. Om deze permissies op een begrijpelijke manier te presenteren, wordt een hulpmethode gecreëerd die de octale waarde van een bestand omzet in een string van leesbare permissies.

Het gebruik van een enum, genaamd Owner, maakt het mogelijk om verschillende gebruikersrollen (zoals User, Group en Other) te onderscheiden en de juiste bitmaskers voor deze rollen te berekenen. Dit is essentieel voor het verwerken van de toegangsrechten, omdat de rechten voor elk type eigenaar verschillen. Elk van deze rechten wordt gedefinieerd als een 3-bits masker (voor lezen, schrijven en uitvoeren), en het bijbehorende masker wordt gebruikt om te bepalen welke rechten er van toepassing zijn op een bepaald bestand of directory.

rust
Copy code
#[derive(Clone, Copy)]

pub enum Owner {
    User,
    Group,
    Other,
}
impl Owner {
    pub fn masks(&self) -> [u32; 3] {
        match self {
            Self::User => [0o400, 0o200, 0o100],

            Self::Group => [0o040, 0o020, 0o010],

            Self::Other => [0o004, 0o002, 0o001],
        }
    }
}

Het volgende deel van de code behandelt het omzetten van de octale permissies naar een leesbare string, bijvoorbeeld "rwx" voor de eigenaar, "r-x" voor de groep, en "--x" voor anderen. Dit wordt bereikt door de maskers toe te passen op de octale waarde van de bestandstoegangsrechten.

rust
Copy code
/// Gegeven een octale waarde zoals 0o500 en een [`Owner`],

/// retourneer een string zoals "r-x"
fn mk_triple(mode: u32, owner: Owner) -> String {
    let [read, write, execute] = owner.masks();
    format!(
        "{}{}{}",

        if mode & read == 0 { "-" } else { "r" },

        if mode & write == 0 { "-" } else { "w" },

        if mode & execute == 0 { "-" } else { "x" },

    )
}

Deze functie genereert de stringrepresentatie van de bestandstoegangsrechten door bitmaskers toe te passen op de bestandstoegangsmodus. Het resultaat is een string die aangeeft of een bepaald recht is ingesteld, bijvoorbeeld "rwx" of "r--". Dit maakt het mogelijk om de toegangsrechten op een gebruiksvriendelijke manier weer te geven.

rust
Copy code
/// Gegeven een bestandsmodus in octale vorm zoals 0o751,
/// retourneer een string zoals "rwxr-x--x"

fn format_mode(mode: u32) -> String {

    format!(
        "{}{}{}",
        mk_triple(mode, Owner::User),
        mk_triple(mode, Owner::Group),
        mk_triple(mode, Owner::Other),
    )
}

Door de afzonderlijke delen van de bestandspermissies te combineren, ontstaat een volledige weergave van de toegangsrechten. Dit maakt het voor de gebruiker mogelijk om in één oogopslag te zien welke rechten van toepassing zijn op een bestand of directory.

Tot slot wordt de output van deze informatie geformatteerd in een tabel, die de bestandsnaam, toegangsrechten, eigenaar, groep, bestandsgrootte, en het laatste wijzigingsmoment bevat. Dit wordt bereikt door de gegevens in een tabelstructuur te plaatsen, wat een overzichtelijke en goed georganiseerde weergave biedt.

rust
Copy code
fn format_output(paths: &[PathBuf]) -> Result<()> {

    let fmt = "{:<}{:<}  {:>}  {:<}  {:<}  {:>}  {:<}  {:<}";
    let mut table = Table::new(fmt);
    for path in paths {
        let metadata = path.metadata()?;
        let uid = metadata.uid();
        let user = get_user_by_uid(uid)

            .map(|u| u.name().to_string_lossy().into_owned())

            .unwrap_or_else(|| uid.to_string());
        let gid = metadata.gid();
        let group = get_group_by_gid(gid)
            .map(|g| g.name().to_string_lossy().into_owned())
            .unwrap_or_else(|| gid.to_string());
        let file_type = if path.is_dir() { "d" } else { "-" };
        let perms = format_mode(metadata.mode());

        let modified: DateTime = DateTime::from(metadata.modified()?);

        table.add_row(
            Row::new()
                .with_cell(file_type)
                .with_cell(perms)
                .with_cell(metadata.nlink())
                .with_cell(user)
                .with_cell(group)
                .with_cell(metadata.len())
                .with_cell(modified.format("%b %d %y %H:%M"))
                .with_cell(path.display()),
        );
    }
    Ok(())
}

De tabel biedt een gestructureerde weergave van elk bestand of directory, inclusief de belangrijke informatie zoals permissies, eigenaar, groepsnaam, bestandsgrootte en het moment van de laatste wijziging. Deze weergave maakt het eenvoudiger om een duidelijk overzicht van bestanden en hun eigenschappen te verkrijgen.

Naast de technieken die hierboven zijn besproken, is het essentieel voor de gebruiker om te begrijpen hoe bestanden in een systeem worden georganiseerd en hoe het besturingssysteem toegang controleert op basis van bestandspermissies. Het is ook belangrijk te weten dat het werken met bestandspermissies en metadata invloed kan hebben op de beveiliging en toegang tot systeembronnen. Dit stelt de ontwikkelaar in staat om niet alleen bestandsinformatie op te halen, maar ook om inzicht te krijgen in de manier waarop de toegang tot gegevens wordt geregeld.