Hoe Werkt het Commando cat in Unix-systemen en Hoe Schrijf je een Rust-versie van dit Programma?

Het commando cat is een veelzijdige Unix-tool die oorspronkelijk werd ontwikkeld om de inhoud van meerdere bestanden aan elkaar te koppelen en naar de standaarduitvoer (STDOUT) te sturen. In de loop der tijd heeft het echter veel andere gebruiksmogelijkheden gekregen, zoals het eenvoudig weergeven van de inhoud van een enkel bestand of het nummeren van regels voor beter overzicht. Dit artikel behandelt de basisfunctionaliteit van cat, enkele geavanceerde opties, en hoe je een versie van dit programma kunt schrijven in de programmeertaal Rust.

shell
Copy code
$ cat tests/inputs/empty.txt

Aangezien het bestand empty.txt leeg is, zal dit commando geen uitvoer opleveren. Dit toont aan dat lege bestanden weliswaar vaak aanwezig zijn in veel systemen, maar weinig functionele waarde hebben. Anderzijds, bij het uitvoeren van cat op een bestand met inhoud, zoals fox.txt, dat de zin "The quick brown fox jumps over the lazy dog." bevat, wordt de volledige inhoud naar de terminal gestuurd:

shell
Copy code
$ cat tests/inputs/fox.txt

The quick brown fox jumps over the lazy dog.

Een van de handigste functies van cat is de mogelijkheid om lijnnummers toe te voegen aan de uitvoer. Dit kan worden bereikt met de -n of --number vlag:

shell
Copy code
$ cat -n tests/inputs/fox.txt
     1    The quick brown fox jumps over the lazy dog.

shell
Copy code
$ cat -n tests/inputs/fox.txt | cat -t
     1^IThe quick brown fox jumps over the lazy dog.

pgsql
Copy code
$ cat -n tests/inputs/the-bustle.txt
     1    The bustle in a house
     2    The morning after death
     3    Is solemnest of industries
     4    Enacted upon earth,—
     5    
     6    The sweeping up the heart,
     7    And putting love away
     8    We shall not want to use again
     9    Until eternity.

En bij gebruik van de -b optie:

pgsql
Copy code
$ cat -b tests/inputs/the-bustle.txt

     1    The bustle in a house
     2    The morning after death
     3    Is solemnest of industries
     4    Enacted upon earth,—
     5    The sweeping up the heart,
     6    And putting love away
     7    We shall not want to use again
     8    Until eternity.

Het is ook mogelijk om beide opties samen te gebruiken, maar zoals blijkt uit de documentatie, heeft de -b vlag prioriteit over -n.

Bij het werken met cat kunnen er situaties optreden waarin een bestand niet toegankelijk is, zoals in het geval van een bestand zonder leesrechten of een bestand dat niet bestaat. In zulke gevallen zal cat een foutmelding weergeven, maar doorgaan met de verwerking van de andere bestanden. Bijvoorbeeld, als je probeert om de inhoud van een bestand genaamd cant-touch-this dat geen leesrechten heeft, samen met andere bestanden te lezen:

shell
Copy code
$ touch cant-touch-this && chmod 000 cant-touch-this
$ cat tests/inputs/fox.txt blargh tests/inputs/spiders.txt cant-touch-this
The quick brown fox jumps over the lazy dog.
cat: blargh: No such file or directory
Don't worry, spiders,
I keep house casually.
cat: cant-touch-this: Permission denied

In dit geval geeft cat een foutmelding voor de bestanden die niet kunnen worden geopend, maar blijft het programma verder werken met de andere bestanden.

shell
Copy code
$ cat -n tests/inputs/empty.txt fox.txt spiders.txt the-bustle.txt
     1    The quick brown fox jumps over the lazy dog.
     1    Don't worry, spiders,
     2    I keep house
     3    casually.
     1    The bustle in a house
     2    The morning after death
     3    Is solemnest of industries
     4    Enacted upon earth,—
     5    
     6    The sweeping up the heart,
     7    And putting love away
     8    We shall not want to use again
     9    Until eternity.

Deze uitvoer wordt gegenereerd door de combinatie van bestanden die samen in één operatie worden gelezen.

Nu we de basisprincipes van cat hebben besproken, is het tijd om een versie van dit programma te schrijven in Rust. Om te beginnen met het schrijven van de uitdaging, creëren we een nieuw Rust-project genaamd catr. Dit kan worden gedaan door het commando cargo new catr uit te voeren. Dit zal een nieuwe map en projectstructuur genereren die we kunnen gebruiken voor onze implementatie.

De eerste stap is het toevoegen van enkele afhankelijkheden in de Cargo.toml file, zoals anyhow, clap, en rand voor hulp bij de besturing van de commandoregel en het genereren van willekeurige testdata. Nadat de basisstructuur is opgezet, kun je beginnen met het definiëren van de parameters van je programma. Dit kan bijvoorbeeld door een struct te maken die de naam van de inputbestanden en de twee booleaanse vlaggen voor het nummeren van de regels bevat.

Het testen van de code speelt een belangrijke rol in het ontwikkelingsproces. Het schrijven van tests vóór het schrijven van de daadwerkelijke code, zoals aanbevolen in Test-Driven Development (TDD), zorgt ervoor dat de functionaliteit van de applicatie van meet af aan wordt gecontroleerd. Dit vereist het kopiëren van de testbestanden en het uitvoeren van tests om ervoor te zorgen dat de implementatie van het programma correct is.

Hoe een Reguliere Expressie Werken in Rust: Praktische Implementatie en Testen

Het schrijven van een programma dat bestanden doorzoekt en specifieke regels vindt op basis van een reguliere expressie (regex), kan een krachtig hulpmiddel zijn voor verschillende tekstverwerkings- en zoektoepassingen. In Rust, een taal die bekend staat om zijn robuuste foutafhandelingsmechanismen en prestaties, kunnen dergelijke programma's efficiënt worden geschreven met behulp van enkele eenvoudige concepten zoals BufRead, regex::Regex, en foutafhandelingsstrategieën.

De functie find_lines krijgt drie argumenten: de tekstbron die we willen doorzoeken, een gecompileerde reguliere expressie en een boolean die bepaalt of we de zoekopdracht omdraaien (inverteren). Het doel van deze functie is om regels te vinden die overeenkomen (of niet, afhankelijk van de invert parameter) met de opgegeven patroon.

rust
Copy code
fn find_lines(

    mut file: T, 
    pattern: &Regex, 
    invert: bool,
) -> Result<Vec<String>> { 
    unimplemented!(); 
}

De parameter file is een type dat de std::io::BufRead trait moet implementeren, wat betekent dat we te maken hebben met een tekstbestand of een andere bron die regel voor regel gelezen kan worden. De reguliere expressie (pattern) is een referentie naar een gecompileerde regex, die het daadwerkelijke patroon vertegenwoordigt waarmee we de regels willen vergelijken. De invert parameter is een booleaanse waarde die bepaalt of we de zoekresultaten willen omkeren: als deze true is, zoekt de functie naar regels die niet overeenkomen met het patroon.

In een typische toepassing, bijvoorbeeld, kan de gebruiker kiezen om tekst te zoeken die een bepaald woord bevat. Als de gebruiker echter niet geïnteresseerd is in regels die dat woord bevatten, kan hij de omgekeerde zoekoptie gebruiken.

Om de implementatie van find_lines te testen, kun je gebruikmaken van std::io::Cursor. Deze structuur maakt het mogelijk om een zogenaamde "valse bestandshandle" te creëren, wat handig is voor het testen van functies zonder daadwerkelijke bestanden te hoeven openen. Hieronder staat een voorbeeld van een testmodule die we toevoegen om onze find_lines functie te testen:

rust
Copy code
#[cfg(test)] 

mod test { 
    use super::{find_files, find_lines}; 
    use regex::{Regex, RegexBuilder}; 
    use std::io::Cursor; 
    #[test] 
    fn test_find_lines() { 
        let text = b"Lorem\nIpsum\r\nDOLOR"; 
        let re1 = Regex::new("or").unwrap(); 

        let matches = find_lines(Cursor::new(&text), &re1, false); 

        assert!(matches.is_ok()); 
        assert_eq!(matches.unwrap().len(), 1); 

        let matches = find_lines(Cursor::new(&text), &re1, true); 

        assert!(matches.is_ok()); 
        assert_eq!(matches.unwrap().len(), 2); 

        let re2 = RegexBuilder::new("or") 

            .case_insensitive(true) 
            .build() 
            .unwrap(); 
        let matches = find_lines(Cursor::new(&text), &re2, false); 
        assert!(matches.is_ok()); 

        assert_eq!(matches.unwrap().len(), 2); 

        let matches = find_lines(Cursor::new(&text), &re2, true); 
        assert!(matches.is_ok()); 

        assert_eq!(matches.unwrap().len(), 1); 

    } 
}

In de bovenstaande test controleren we verschillende scenario’s met regex-patronen, zoals het zoeken naar een specifiek woord ("or"), het negeren van hoofdletters (case-insensitief), en het omkeren van de zoekresultaten. Het is van belang om te begrijpen dat regex in Rust case-sensitief is, tenzij anders gespecificeerd.

Een andere belangrijke overweging bij het ontwikkelen van een programma zoals dit, is het gebruik van de find_files functie, die verantwoordelijk is voor het vinden van bestanden die we willen doorzoeken. Deze functie maakt gebruik van de WalkDir crate om bestanden in een directory en diens subdirectories te doorzoeken. Het is ook belangrijk om goed om te gaan met fouten, zoals wanneer een bestand niet kan worden geopend of niet bestaat.

rust
Copy code
fn find_files(paths: &[String], recursive: bool) -> Vec<Result<String>> { 

    let mut results = vec![]; 
    for path in paths { 
        match path.as_str() { 
            "-" => results.push(Ok(path.to_string())), 
            _ => match fs::metadata(path) { 
                Ok(metadata) => { 
                    if metadata.is_dir() { 
                        if recursive { 

                            for entry in WalkDir::new(path) 

                                .into_iter() 
                                .flatten() 
                                .filter(|e| e.file_type().is_file()) { 
                                    results.push(Ok(entry 
                                        .path() 
                                        .display() 
                                        .to_string())); 
                            } 
                        } else { 

                            results.push(Err(anyhow!("{path} is a directory"))); 

                        } 
                    } else if metadata.is_file() { 
                        results.push(Ok(path.to_string())); 
                    }
                }
            }
        }
    }
    results
}

Naast het vinden van bestanden, is het ook belangrijk dat het programma correcte foutmeldingen geeft wanneer er problemen zijn, zoals een niet-bestaand bestand of een bestand dat om welke reden dan ook niet geopend kan worden (bijvoorbeeld door onvoldoende machtigingen). Dit kan worden bereikt door specifieke foutmeldingen te tonen, zoals No such file or directory of Permission denied.

Daarnaast is het belangrijk om na te denken over hoe het programma op verschillende invoerbestanden en met verschillende regex-patronen werkt. Dit betekent dat je het programma moet testen met verschillende soorten tekstbestanden, verschillende patronen en verschillende opties, zoals het inschakelen van hoofdlettergevoeligheid, het omkeren van de zoekopdracht of het tellen van het aantal overeenkomsten in plaats van de overeenkomende regels zelf af te drukken.

Het gebruik van een gebruiksvriendelijke interface met goed gedefinieerde opties, zoals --insensitive, --count, en --invert-match, kan de functionaliteit van het programma aanzienlijk uitbreiden. Het biedt gebruikers meer controle over hoe ze hun zoekopdrachten uitvoeren, en maakt het programma veelzijdiger.

Hoe de comm Tool te Gebruiken voor Bestandsvergelijking in Rust

De comm-tool is een krachtige manier om twee gesorteerde bestanden regel voor regel te vergelijken en de overeenkomsten of verschillen tussen hen te identificeren. Het wordt vaak gebruikt in situaties waar je te maken hebt met datasets die je wilt vergelijken, bijvoorbeeld om te vinden welke items in beide bestanden aanwezig zijn of juist welke specifiek voor elk bestand zijn. Dit kan van pas komen in een breed scala van toepassingen, van het vergelijken van lijsten van steden tot het identificeren van overlappen tussen grote biologische datasets.

De basisfunctionaliteit van comm bestaat uit drie kolommen. De eerste kolom bevat de regels die uniek zijn voor het eerste bestand, de tweede kolom de regels die uniek zijn voor het tweede bestand, en de derde kolom de regels die in beide bestanden voorkomen. Dit is ideaal voor gevallen waar je de overlap tussen twee gegevenssets wilt begrijpen. Het gebruik van verschillende opties maakt het mogelijk om specifieke kolommen te onderdrukken of de vergelijking verder aan te passen, afhankelijk van de vereisten van de taak.

Bijvoorbeeld, stel dat je twee tekstbestanden hebt, een voor steden die je favoriete band tijdens hun eerste tour bezocht, en een ander voor steden van hun huidige tour. Door de comm-tool te gebruiken, kun je snel de gemeenschappelijke steden tussen de twee tourdata identificeren door de kolommen die alleen in één bestand voorkomen te onderdrukken. Dit werkt door de juiste kolommen in je comm-opdracht te specificeren.

Als beide bestanden bijvoorbeeld gesorteerd zijn, kun je de gemeenschappelijke steden eenvoudig vinden met de volgende opdracht:

bash
Copy code
comm -12 <(sort cities1.txt) <(sort cities2.txt)

Deze opdracht toont enkel de gemeenschappelijke steden tussen de twee tourdata. Maar je kunt ook andere varianten gebruiken om specifieke steden te vinden die exclusief in het eerste of tweede bestand staan:

bash
Copy code
comm -23 <(sort cities1.txt) <(sort cities2.txt)

Dit toont enkel de steden die in het eerste bestand staan, maar niet in het tweede bestand. Evenzo kun je een vergelijkbare aanpak gebruiken om alleen de steden te vinden die alleen in het tweede bestand staan.

Naast de basisfunctionaliteit biedt comm verschillende opties, zoals het controleren of de bestanden correct zijn gesorteerd met de optie --check-order. Als de bestanden niet gesorteerd zijn, kun je dat met de optie --nocheck-order expliciet aangeven. De optie --output-delimiter geeft je de mogelijkheid om de scheidingstekens tussen de kolommen aan te passen, die standaard een tab-teken zijn. De -i-optie maakt het mogelijk om hoofdlettergevoelige vergelijkingen uit te voeren, wat handig is bij tekst die niet consistent is in hoofdlettergebruik.

Voor een meer geavanceerd gebruik kun je comm in combinatie met andere tools zoals sort of grep gebruiken om efficiënter te werken met grote hoeveelheden gegevens. In bioinformatica bijvoorbeeld, kun je comm gebruiken om eiwitsequenties te vergelijken die al in clusters zijn gegroepeerd, en zo te identificeren welke sequenties niet succesvol zijn geclusterd. Dit kan nuttige informatie opleveren voor verder onderzoek naar de eigenschappen van deze ongeclusterde eiwitten.

Bij het implementeren van deze functionaliteit in een programma zoals commr in Rust, begin je doorgaans met het definiëren van de argumenten die het programma moet accepteren. In dit geval gaat het om het verwerken van twee bestanden en het kiezen welke kolommen getoond moeten worden, evenals het instellen van de scheidingstekens en het inschakelen van case-insensitive vergelijking. Het is belangrijk dat je bij het ontwerpen van de argumenten duidelijke namen kiest die de bedoeling van elke optie weerspiegelen. Dit maakt de code leesbaarder en eenvoudiger te onderhouden.

In de volgende stap implementeer je een functie die de argumenten van de commandoregel inleest en de juiste opties doorgeeft aan je programma. Een typisch voorbeeld van deze code in Rust zou eruitzien als volgt:

rust
Copy code
fn get_args() -> Args {

    let matches = Command::new("commr")

        .version("0.1.0")
        .author("Ken Youens-Clark")
        .about("Rust versie van `comm`")
        .get_matches();
    Args {
        file1: matches.value_of("file1").unwrap().to_string(),

        file2: matches.value_of("file2").unwrap().to_string(),

        show_col1: matches.is_present("show_col1"),
        show_col2: matches.is_present("show_col2"),
        show_col3: matches.is_present("show_col3"),
        insensitive: matches.is_present("insensitive"),
        delimiter: matches.value_of("delimiter").unwrap_or("\t").to_string(),
    }
}

Deze functie verwerkt de argumenten en maakt ze beschikbaar voor gebruik binnen je programma. De main-functie zou vervolgens de door de gebruiker opgegeven argumenten kunnen afdrukken of verder verwerken om de gewenste vergelijking uit te voeren.