Hvordan lage en Rust-versjon av Fortune-programmet

I denne delen vil vi lage et Rust-basert program som simulerer det klassiske Unix-programmet fortune. Dette programmet velger tilfeldig et visdomsord, trivium eller ASCII-kunst fra en samling av tekstfiler og viser det til brukeren. Dette programmet får sitt navn fra fortune-kjeksen, en sprø kake som inneholder en liten lapp med en kort tekst, som kanskje er en spådom eller et kort vittighet. For meg, som lærte å bruke et Unix-terminal på universitetet, var det ofte en vellykket pålogging som inkluderte utskriften fra fortune.

Hvordan Fortune fungerer

Kildefiler og Strukturen til Fortune

Som standard leser Fortune fra en eller flere tekstfiler. Disse filene inneholder tekstoppskrifter som er delt inn i flere kategorier, som noen ganger kan være potensielt støtende og andre ganger ikke. På et system kan filene være plassert i katalogene som følgende:

• /opt/homebrew/Cellar/fortune/9708/share/games/fortunes for ikke-støtende fortune

• /opt/homebrew/Cellar/fortune/9708/share/games/fortunes/off for støtende fortune

Disse tekstene kan være humoristiske, inspirerende eller tilfeldige observasjoner. Hver post i disse filene er delt opp i flere linjer og avsluttes med et prosenttegn (%), som indikerer slutten på ett fortune.

For eksempel kan en humoristisk post i tekstfilen se slik ut:

makefile
Copy code
Q: Hva kaller du et hode av salat i skjorte og slips?
A: Collared greens.
%
Q: Hvorfor sluttet gartneren i jobben sin?
A: Hans selleri var ikke høy nok.
%

Hvordan programmet kan bruke tekstkilder

Indexering av Tekstfiler

For å bruke disse tekstene i programmet vårt, må vi først indeksere filene ved å bruke et verktøy som kalles strfile. Dette verktøyet lager indeksfiler (.dat) som hjelper programmet med å hente en tilfeldig post fra tekstfilene. Etter at filene er indeksert, kan vi bruke kommandoen fortune til å velge en post fra filene, for eksempel:

r
Copy code
$ fortune tests/inputs/ascii-art

            .--._.--.
           ( O     O )
           /   . .   \
          .`._______.'.
         /(           )\
       _/  \  \   /  /  \_  
      .~   `  \  \ /  /  '   ~.
   {    -.   \  V  /   .-    }
   _ _`.    \  |  |  |  /    .'_ _ >_

Hvis du ønsker å finne spesifikke tekster som inneholder et visst mønster, kan du bruke flagget -m etterfulgt av et mønster for å filtrere hvilke poster som vises. For eksempel:

shell
Copy code
$ fortune -m 'Yogi Berra' tests/inputs/

Dette vil vise alle poster som inneholder sitater fra Yogi Berra.

Feilhåndtering og Filtrering

Dersom du angir en filbane som ikke eksisterer, vil programmet straks gi en feilmelding og stoppe:

shell
Copy code
$ fortune tests/inputs/jokes blargh
blargh: No such file or directory

I tilfeller hvor en fil eksisterer, men ikke kan leses, kan Fortune-programmet vise feilmeldinger om at filen ikke er tilgjengelig. Dette er nyttig å vite når man bygger et slikt program, for det er viktig å ha ordentlig feilhåndtering på plass.

Hvordan programmet vårt fungerer

I dette kapittelet skal vi bygge et Rust-program som etterligner funksjonaliteten til det klassiske fortune-programmet. Dette programmet vil bruke Rusts robuste filbehandling og tilfeldige tallgenerator for å hente og vise tekstene på en liknende måte.

For å begynne, skal vi bruke Path og PathBuf for å representere systemets stier til filene. Vi skal også lære hvordan man parser tekst som strekker seg over flere linjer, og hvordan man kan kontrollere tilfeldige valg med seed.

Viktige konsept å forstå

Ved å implementere et program som Fortune, lærer man hvordan man jobber med filsystemet i Rust, hvordan man behandler tekstfiler og hvordan man kan manipulere og bruke tilfeldige data. Dette er viktige ferdigheter som er nødvendige når man bygger systemer som krever datamanipulering og høy kontroll over eksterne ressurser. Å forstå hvordan man kan håndtere tekstbaserte data, indeksere dem og hente spesifik informasjon, er essensielt for mange programmeringsteknikker.

Endtext

Hvordan skrive en funksjon for å analysere og validere måneder i et program

For å implementere en funksjon som kan analysere og validere månedsinndata, er det viktig å være både presis og fleksibel. Programmet vårt bør kunne håndtere både numeriske verdier og strengrepresentasjoner av måneder. Det betyr at vi må sørge for at programmet kan:

1. Validere numeriske verdier (som 1 til 12).

2. Håndtere ufullstendige eller feilstavede månedens navn.

3. Være følsom for store og små bokstaver i månedsnavnene.

4. Gi klare feilmeldinger dersom inndataene er ugyldige.

I denne løsningen bruker vi et array med gyldige månedsnavn som referanse. Vi definerer konstanten MONTH_NAMES for å lagre navnene på alle tolv månedene:

rust
Copy code
const MONTH_NAMES: [&str; 12] = [

    "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
];

Funksjonen parse_month

Funksjonen prøver først å tolke måneden som et tall. Hvis tallet er mellom 1 og 12, returnerer den verdien direkte. Hvis tallet er utenfor dette området, genereres en feilmelding.

rust
Copy code
fn parse_month(month: String) -> Result<u32, String> {
    match month.parse::<u32>() {
        Ok(num) => {

            if (1..=12).contains(&num) {

                Ok(num)
            } else {
                Err(format!(r#"month "{}" not in the range 1 through 12"#, month))
            }
        }
        Err(_) => {
            let lower = month.to_lowercase();
            let matches: Vec<_> = MONTH_NAMES
                .iter()
                .enumerate()
                .filter_map(|(i, name)| {
                    if name.to_lowercase().starts_with(&lower) {
                        Some(i + 1)
                    } else {
                        None
                    }
                })
                .collect();
            if matches.len() == 1 {

                Ok(matches[0] as u32)

            } else {
                Err(format!(r#"Invalid month "{}""#, month))
            }
        }
    }
}

Hvordan fungerer parse_month?

1. Tolkning av tall: Hvis strengen kan konverteres til et tall (for eksempel "5"), blir det sjekket om tallet er innenfor gyldige månedstall (1–12). Hvis det er, returneres tallet. Hvis tallet er utenfor dette området, genereres en feilmelding som forklarer at tallet er ugyldig.

2. Tolkning av månedsnavn: Hvis strengen ikke kan konverteres til et tall, forsøker funksjonen å matche strengen med månedsnavnene i MONTH_NAMES. Ved å sammenligne den lavere case-versjonen av strengen med de lavere case-versjonene av månedsnavnene, finner vi ut hvilke månedsnavn som begynner med den gitte strengen. Hvis det finnes flere mulige måneder, returnerer funksjonen en feilmelding om tvetydighet. Hvis det finnes en entydig match, returneres måneden som et tall.

Håndtering av kommandoargumenter

I programmet kan vi bruke funksjonen parse_month for å validere månedene som gis via kommandoargumentene. Dette kan gjøres i en funksjon som heter run, som tar inn et Args-objekt som inneholder informasjon om måned og år.

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

    let today = chrono::Local::now().date_naive();

    let mut month = args.month.map(parse_month).transpose()?;

    let mut year = args.year;
    if args.show_current_year {
        month = None;
        year = Some(today.year());
    } else if month.is_none() && year.is_none() {
        month = Some(today.month());
        year = Some(today.year());
    }

    let year = year.unwrap_or(today.year());

    println!("month = {month:?}");
    println!("year  = {year:?}");
    Ok(())
}

Denne funksjonen håndterer både tilfeller der måneden eller året er spesifisert via argumenter, samt tilfeller der de ikke er det. Den bruker også den nåværende datoen hvis ingen argumenter er gitt, og gir mulighet for å vise det nåværende året alene med flagget -y.

Feilhåndtering og feilmeldinger

Programmet er også i stand til å håndtere ufullstendige månednavn (som "Jul" for "July" eller "Jul" for "June") så lenge det er en entydig match.

Ekstra betraktninger

Når man jobber med datoer og måneder i et program, er det viktig å tenke på kulturspesifikke forskjeller i hvordan datoer presenteres og tolkes. For eksempel kan månedsnavnene variere på forskjellige språk. I tillegg er det viktig å merke seg at månedsnummereringen i dataprogrammer ofte er 1-baserte (1 for januar, 2 for februar, osv.), mens enkelte systemer kan bruke 0-basert nummerering (0 for januar, 1 for februar, osv.).

Endret datoformat kan også føre til problemer, for eksempel hvis brukeren gir en dato på et annet språk eller i et annet format. Feilhåndtering og tilbakemeldinger er derfor kritisk for å sikre en god brukeropplevelse.

Hvordan implementere en enkel versjon av ls i Rust

Programmet ls er en av de mest brukte kommandoene i Unix-lignende operativsystemer. Det brukes til å vise innholdet i en katalog og kan tilpasses med forskjellige alternativer for å vise detaljerte metadata om filene og katalogene. I denne artikkelen vil vi gå gjennom en enkel implementering av et program som etterligner funksjonaliteten til ls ved hjelp av Rust. Vi vil fokusere på to grunnleggende alternativer: -l for lang visning og -a for å vise skjulte filer.

Når du kjører ls uten noen alternativer, viser det innholdet i den nåværende katalogen. Hvis du for eksempel bytter til katalogen 14_lsr og kjører kommandoen $ ls, vil du se noe som dette:

shell
Copy code
$ cd 14_lsr
$ ls
Cargo.toml         set-test-perms.sh* src/               tests/

Som standard viser ls navnene på filene og katalogene i den gjeldende katalogen. Filene som er kataloger, vises på en egen linje og skilles fra vanlige filer.

diff
Copy code
$ ls -l
total 16
-rw-r--r--  1 kyclark  staff  217 Aug 11 08:26 Cargo.toml
-rwxr-xr-x  1 kyclark  staff  447 Aug 12 17:56 set-test-perms.sh*
drwxr-xr-x  5 kyclark  staff  160 Aug 26 09:44 src/
drwxr-xr-x  4 kyclark  staff  128 Aug 17 08:42 tests/

Når alternativet -a brukes, vil skjulte filer vises, inkludert de spesielle katalogene . (nåværende katalog) og .. (foreldrekatalog). Vanligvis vises ikke slike filer i standard ls-utgang, men med -a kan du se dem:

shell
Copy code
$ ls -a

./                 Cargo.toml         src/
../                set-test-perms.sh* tests/

Skjulte filer begynner vanligvis med et punktum (.), og de brukes ofte til å lagre programtilstand eller metadata. For eksempel inneholder katalogen .git all informasjon Git trenger for å spore endringer i filene.

Ved å kombinere alternativer, som -la eller -al, kan du få både skjulte filer og lang visning i én kommando:

diff
Copy code
$ ls -la
total 16
drwxr-xr-x   6 kyclark  staff  192 Oct 15 07:52 ./
drwxr-xr-x  24 kyclark  staff  768 Aug 24 08:22 ../
-rw-r--r--   1 kyclark  staff  217 Aug 11 08:26 Cargo.toml
-rwxr-xr-x   1 kyclark  staff  447 Aug 12 17:56 set-test-perms.sh*
drwxr-xr-x   5 kyclark  staff  160 Aug 26 09:44 src/
drwxr-xr-x   4 kyclark  staff  128 Aug 17 08:42 tests/

Når du arbeider med filsystemer, er det også viktig å forstå hvordan kataloger og filer er organisert. Når du bruker ls med en spesifisert sti til en katalog, som for eksempel ls src/ tests/, vil innholdet i de spesifikke katalogene vises, og skjulte filer og kataloger kan også vises avhengig av de valgte alternativene.

makefile
Copy code
$ ls src/ tests/

src/: main.rs   owner.rs
tests/: cli.rs  inputs

I tilfelle du ønsker å liste ut bestemte typer filer, som for eksempel alle .rs-filene i src/-katalogen, kan du bruke jokertegn:

bash
Copy code
$ ls -l src/*.rs
-rw-r--r--  1 kyclark  staff  8959 Feb 25 12:09 src/main.rs
-rw-r--r--  1 kyclark  staff   313 Feb 25 12:03 src/owner.rs

I utviklingen av et program som simulerer ls i Rust, kan man bruke flere eksterne biblioteker for å forenkle implementeringen. Biblioteket chrono kan for eksempel brukes til å håndtere tidspunktene for filmodifikasjoner, og tabular kan brukes til å presentere data i et pent tabellformat. I tillegg vil biblioteket users hjelpe til med å hente ut eier- og gruppeinformasjon for filer og kataloger.

For å komme i gang kan du opprette et nytt Rust-prosjekt med kommandoen cargo new lsr, og deretter legge til nødvendige avhengigheter i Cargo.toml:

toml
Copy code
[dependencies]

anyhow = "1.0.79"
chrono = "0.4.31"
clap = { version = "4.5.0", features = ["derive"] }
tabular = "0.2.0"
users = "0.11.0"
[dev-dependencies]
assert_cmd = "2.0.13"
predicates = "3.0.4"
pretty_assertions = "1.4.0"
rand = "0.8.5"

Når prosjektet er satt opp, kan du begynne å implementere logikken for håndtering av filsystemet og brukerinndata. Et viktig steg er å kunne analysere og validere argumentene som gis til programmet, for eksempel hvilke stier som skal listes, om den lange visningen skal vises, og om skjulte filer skal inkluderes. Dette kan gjøres ved hjelp av biblioteket clap for argumentparsing.

For å håndtere filsystemet kan du bruke standardbiblioteket std::fs for å lese kataloginnhold og hente filmetadata. Kombinert med biblioteker som chrono og users, kan du enkelt formatere og vise de nødvendige detaljene om filene.