Jak poprawnie obsługiwać argumenty i błędy w programie CLI w języku Rust?

W programach działających w trybie wiersza poleceń, kluczowe jest prawidłowe przetwarzanie argumentów oraz efektywne zarządzanie komunikatami o błędach. Kiedy piszemy programy w takim środowisku, jednym z najważniejszych aspektów jest zachowanie porządku między standardowym wyjściem (STDOUT) a wyjściem błędów (STDERR). Dobrym przykładem jest sytuacja, w której program przetwarza argumenty i napotyka błędy. Wiadomo, że błędy mogą występować na różnych etapach działania programu i ich obsługa powinna być uzależniona od ich powagi.

Kiedy uruchamiamy program, który nie otrzymał wymaganych argumentów, nie powinien on nic wypisywać na STDOUT, ale błędy powinny zostać zapisane do pliku błędów (stderr). Typowy komunikat błędu może wyglądać następująco:

javascript
Copy code
$ cat err

Finished dev [unoptimized + debuginfo] target(s) in 0.08s
Running `target/debug/echor`
error: the following required arguments were not provided:
Usage: echor ...
For more information, try '--help'.

Kiedy już przetworzymy argumenty programu, możemy przejść do generowania wyników, które przypominają działanie komendy echo. Jednym z ważniejszych elementów w tym przypadku jest sposób obsługi tekstu wejściowego. Aby przechować argumenty tekstowe (mogące składać się z jednej lub kilku fraz), można wykorzystać typ wektora (Vec). Wartości te są reprezentowane jako String w języku Rust, a ich przetwarzanie może przebiegać w kilku krokach.

W pierwszym kroku musimy wyciągnąć wartość argumentu z przekazanych danych. Możemy to zrobić za pomocą metody ArgMatches::get_many, która pozwala na pobranie wielu wartości argumentu w postaci iteratora. Ponieważ nie zawsze możemy mieć pewność, że wartości te będą dostępne, wynikiem tej metody jest typ Option, który może przyjąć jedną z dwóch wartości: None (brak wartości) lub Some (wartość obecna). W przypadku, gdy użytkownik musi dostarczyć co najmniej jedną wartość, możemy bezpiecznie wywołać metodę unwrap, aby wyciągnąć wartość z opcji:

rust
Copy code
let text: Vec<String> = matches.get_many("text").unwrap().cloned().collect();

Należy jednak pamiętać, że wywołanie unwrap na opcji None spowoduje panikę w programie, co może doprowadzić do jego awarii. Dlatego ważne jest, aby w takich przypadkach zachować ostrożność i unikać niepotrzebnych ryzykownych operacji.

Kiedy mamy już przygotowane dane, kolejnym krokiem jest ich wypisanie na ekranie. Dla tego celu możemy wykorzystać metodę join typu Vec, która łączy wszystkie elementy wektora w jeden ciąg znaków, oddzielony określonym separatorem:

rust
Copy code
println!("{}", text.join(" "));

Jest to jedno z częściej używanych podejść w Rust, ponieważ pozwala na łączenie tekstów bez konieczności manualnego iterowania po każdym elemencie tablicy.

rust
Copy code
let omit_newline = matches.get_flag("omit_newline");

let ending = if omit_newline { "" } else { "\n" };

print!("{}{}", text.join(" "), ending);

rust
Copy code
let mut ending = "\n"; // Zmienna musi być mutowalna

Jest to jedno z wielu podejść w języku Rust, które wymusza na programiście świadome podejmowanie decyzji o tym, kiedy i w jaki sposób zmienne mogą być zmieniane.

Należy pamiętać, że niektóre operacje w Rust, takie jak manipulacja pamięcią lub obsługa błędów, mogą różnić się od tych w innych językach, co może wymagać od programisty większej ostrożności i znajomości narzędzi oferowanych przez ten język.

Jak działa program wc i jak go zaimplementować w Rust?

W tym rozdziale stawiasz czoła zadaniu stworzenia programu wc, który jest jednym z klasycznych narzędzi systemu Unix. Program ten służy do liczenia liczby linii, słów oraz bajtów w plikach tekstowych lub w danych wejściowych ze standardowego wejścia (STDIN). Narzędzie to było obecne już w pierwszej wersji systemu AT&T Unix i stało się powszechnie używane w pracy z tekstem. Wiedza na temat jego działania jest nieoceniona, zwłaszcza w kontekście programowania w języku Rust, który charakteryzuje się doskonałą kontrolą nad pamięcią oraz dbałością o bezpieczeństwo typów.

Program wc działa na zasadzie analizy wierszy tekstu, gdzie linia to ciąg znaków zakończony znakiem nowej linii (\n). Słowa są zdefiniowane jako ciągi znaków oddzielone białymi znakami, natomiast bajty odpowiadają wszystkim jednostkom danych, w tym także wielobajtowym znakom w systemach z kodowaniem Unicode. Funkcjonalność wc jest dość rozbudowana i pozwala na szczegółową kontrolę nad tym, co dokładnie ma być liczone.

Kluczowe aspekty wc

Program wc może przyjmować różne opcje, które pozwalają na wybór rodzaju informacji, które mają być wyświetlane:

• -l – liczba linii,

• -w – liczba słów,

• -c – liczba bajtów,

• -m – liczba znaków (w przypadku Unicode może różnić się od liczby bajtów).

Implementacja wc w Rust

W rozdziale tym nauczyłeś się, jak zaimplementować ten program w języku Rust. Kluczowym elementem, który należy zrozumieć, jest użycie funkcji iterujących oraz manipulacja danymi wejściowymi w celu uzyskania dokładnych wyników. Wszystkie argumenty wiersza poleceń są traktowane jako ciągi znaków, a ich konwersja na odpowiednie typy (liczby całkowite, bajty, znaki) jest fundamentalna dla prawidłowego działania programu.

Manipulacja danymi wejściowymi

Do rozdzielania linii na słowa, bajty lub znaki można wykorzystać funkcje iterujące, takie jak split_whitespace (dzieli na słowa na podstawie białych znaków) oraz bytes (dzieli na bajty). Również ważnym narzędziem w tej operacji jest funkcja take, która pozwala na ograniczenie liczby przetwarzanych elementów, co może okazać się pomocne w trakcie testowania.

Testowanie i debugowanie

Przykłady działania programu wc

Podstawowy przykład działania wc polega na uruchomieniu programu z jednym lub kilkoma plikami tekstowymi. Jeśli plik jest pusty, wynik będzie wskazywał na zerową liczbę linii, słów i bajtów. W przypadku pliku zawierającego jedną linię tekstu, liczba linii wyniesie 1, liczba słów będzie zależała od tego, ile jest słów w tej linii, a liczba bajtów będzie odpowiadała liczbie znaków w tej linii, uwzględniając także białe znaki i tabulatory.

Przykład:

bash
Copy code
$ wc tests/inputs/fox.txt
1 9 48 tests/inputs/fox.txt

Optymalizacja i poprawność

Podczas implementacji programu wc warto również zwrócić uwagę na optymalizację kodu. Rust daje możliwość precyzyjnej kontroli nad pamięcią oraz bezpiecznymi operacjami na danych, dzięki czemu program działa szybko i efektywnie. Dzięki systemowi typów w Rust możliwe jest również uniknięcie wielu typowych błędów związanych z nieprawidłową konwersją danych.

Przygotowując swój program, należy również zadbać o odpowiednie zarządzanie pamięcią i unikać nadmiernego kopiowania danych, co może wpływać na wydajność, zwłaszcza przy dużych plikach tekstowych.

Co warto jeszcze wiedzieć?

Program wc to nie tylko przykład pracy z danymi wejściowymi, ale także świetna okazja do zrozumienia podstawowych zasad pracy z systemem plików i manipulacji tekstem w Rust. Ważne jest, aby pamiętać o różnych typach kodowania (ASCII vs Unicode), co może wpłynąć na różnicę między liczbą bajtów a liczbą znaków. Ponadto warto rozumieć, że wc ma różne wersje, np. wersja GNU i BSD różnią się nieco zachowaniem, szczególnie w kontekście obsługi znaków i długości wyświetlanych wyników.

Jak stworzyć program liczący linie, słowa, znaki i bajty w plikach w Rust?

Najpierw przedstawimy opcje, które będą obsługiwane przez nasz program. Program będzie umożliwiał użytkownikowi wybór, które z liczb mają być wyświetlane: liczba linii, słów, znaków (wielkość w bajtach) oraz długość najdłuższej linii w pliku. Poniżej przedstawiono opcje, które będą obsługiwane przez nasz program:

• -l, --lines: wypisuje liczbę linii w pliku.

• -w, --words: wypisuje liczbę słów w pliku.

• -c, --bytes: wypisuje liczbę bajtów w pliku.

• -m, --chars: wypisuje liczbę znaków w pliku (bez uwzględnienia kodowania).

• --max-line-length: wypisuje długość najdłuższej linii w pliku.

Program ma również możliwość przyjmowania nazw plików, które będą przetwarzane, lub odczytu danych z wejścia standardowego (STDIN), jeśli nie zostaną podane żadne pliki.

Obsługa wielu plików i błędów

Przykład:

bash
Copy code
$ wc tests/inputs/fox.txt blargh tests/inputs/atlamal.txt
wc: blargh: open: No such file or directory
4      29     177 tests/inputs/atlamal.txt
5      38     225 tests/inputs/fox.txt
total

Przekierowanie komunikatów o błędach do pliku err pozwala na zapisanie ostrzeżeń do osobnego pliku:

bash
Copy code
$ wc tests/inputs/fox.txt blargh tests/inputs/atlamal.txt 2>err

wc: blargh: open: No such file or directory

W ten sposób użytkownik może łatwo monitorować błędy.

Przetwarzanie argumentów w wierszu poleceń

Do przetwarzania argumentów wiersza poleceń używamy biblioteki clap. Program, który będziemy pisać, wymaga kilku opcji:

• Lista plików wejściowych.

• Określenie, czy mają być liczone linie, słowa, bajty, czy znaki.

Przykład kodu, który ustawia strukturę do przechowywania tych informacji:

rust
Copy code
#[derive(Debug)]
struct Args {
    files: Vec<String>,
    lines: bool,
    words: bool,
    bytes: bool,
    chars: bool,
}
fn get_args() -> Args {

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

        .version("0.1.0")
        .author("Ken Youens-Clark")
        .about("Rust version of `wc`")
        .arg(Arg::new("files")
            .value_name("FILE")
            .help("Input file(s)")
            .default_value("-")
            .num_args(0..))
        .arg(Arg::new("lines")
            .short('l')
            .long("lines")
            .action(ArgAction::SetTrue)
            .help("Show line count"))
        .arg(Arg::new("words")
            .short('w')
            .long("words")
            .action(ArgAction::SetTrue)
            .help("Show word count"))
        .arg(Arg::new("bytes")
            .short('c')
            .long("bytes")
            .action(ArgAction::SetTrue)
            .help("Show byte count"))
        .arg(Arg::new("chars")
            .short('m')
            .long("chars")
            .action(ArgAction::SetTrue)
            .help("Show character count")
            .conflicts_with("bytes"))
        .get_matches();
    Args {
        files: matches.get_many("files").unwrap().cloned().collect(),
        lines: matches.get_flag("lines"),
        words: matches.get_flag("words"),
        bytes: matches.get_flag("bytes"),
        chars: matches.get_flag("chars"),
    }
}

Domyślne wartości

Program powinien domyślnie liczyć linie, słowa i bajty z wejścia standardowego (STDIN), jeżeli nie podano plików lub żadnych opcji. Używając odpowiednich flag, użytkownik może wymusić liczenie tylko jednej z kategorii: linii, słów, bajtów lub znaków. Program będzie także obsługiwał przypadki, w których użytkownik wybiera niekompatybilne opcje, na przykład flagi -m i -c:

pgsql
Copy code
error: the argument '--bytes' cannot be used with '--chars'

Usage: wcr --bytes ...

Testowanie programu

Warto dodać testy, które będą weryfikować poprawność działania programu. W tym celu można wykorzystać bibliotekę assert_cmd do testowania, czy program poprawnie reaguje na różne przypadki wejściowe. Testy powinny obejmować:

• Sprawdzenie, czy program działa poprawnie z plikami.

• Testowanie różnych opcji wiersza poleceń.

• Obsługę błędów związanych z brakiem pliku.

Początkowo można stworzyć testy w folderze tests/ i uruchamiać je za pomocą cargo test. Każdy test powinien sprawdzać, czy program wykonuje się poprawnie w różnych warunkach.

Obsługa błędów i wyjątków

Należy pamiętać, że program musi obsługiwać błędy w sposób przyjazny dla użytkownika. Korzystanie z biblioteki anyhow do obsługi błędów pozwala na łatwiejsze zarządzanie błędami i ich raportowanie. Jeśli program napotka na problem, na przykład z plikiem, który nie istnieje, powinien wypisać komunikat o błędzie i zakończyć działanie.

Program powinien także obsługiwać przypadki, w których użytkownik nie poda żadnych argumentów. Wtedy domyślne wartości zostaną użyte, a program wykona odpowiednie akcje na standardowym wejściu.