Jak poprawić czytelność i rozbudowalność kodu za pomocą refaktoryzacji w języku Rust

Kiedy przeglądamy kod, który staje się zbyt złożony i trudny do rozszerzenia, jednym z głównych rozwiązań jest jego refaktoryzacja. Chodzi tu o zmianę struktury kodu bez modyfikowania jego działania. W tym kontekście refaktoryzacja umożliwia uproszczenie logiki, poprawę czytelności i łatwiejsze dodawanie nowych funkcjonalności w przyszłości. Proces ten jest szczególnie istotny, gdy kod wchodzi w fazę, w której konieczne jest dodanie nowych kryteriów wyboru, ale istniejące podejście staje się nieczytelne i nieefektywne.

W przypadku kodu przedstawionego w przykładowym zadaniu, zauważamy nadmiar wcięć i złożoność wynikającą z użycia wielu operacji logicznych oraz nawiasów. Każda zmiana w tym kodzie niesie ze sobą ryzyko wprowadzenia błędów, a sam proces rozbudowy programu staje się niepokojąco trudny. Chcielibyśmy więc uprościć kod i jednocześnie utrzymać jego funkcjonalność, korzystając z możliwości, które oferuje język Rust, w tym jego systemu iteracji i filtracji.

Przykładowy kod wykonuje filtrowanie plików i katalogów, przeprowadzając operacje na dwóch głównych parametrach: typie pliku oraz nazwie. Aby osiągnąć zamierzony efekt, używamy dwóch zamknięć (closures), które sprawdzają, czy dany wpis spełnia warunki filtracji.

Pierwsze zamknięcie dotyczy typu pliku i sprawdza, czy plik jest dowiązaniem (symlinkiem), katalogiem lub zwykłym plikiem. Jeśli żadne z tych typów nie zostało określone przez użytkownika, kod zwraca prawdę. W przeciwnym przypadku iteruje po dostępnych typach i porównuje je z typem pliku:

rust
Copy code
let type_filter = |entry: &DirEntry| {

    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(),
        })
};

Drugie zamknięcie działa na nazwach plików, filtrując tylko te, które pasują do przynajmniej jednego z podanych wyrażeń regularnych. Jeżeli lista nazw jest pusta, kod zwróci prawdę, akceptując wszystkie pliki:

rust
Copy code
let name_filter = |entry: &DirEntry| {

    args.names.is_empty() 
        || args.names.iter().any(|re| re.is_match(&entry.file_name().to_string_lossy()))
};

Wszystkie operacje filtracyjne mogą zostać połączone w jeden łańcuch operacji na iteratorze, gdzie filter_map umożliwia obsługę błędów wejściowych, a kolejne operacje filter i map pozwalają na wyodrębnienie i przetworzenie wyników.

rust
Copy code
let entries = WalkDir::new(path)
    .into_iter()
    .filter_map(|e| match e {
        Err(e) => {
            eprintln!("{}", e);
            None
        }
        Ok(entry) => Some(entry),
    })
    .filter(type_filter)
    .filter(name_filter)

    .map(|entry| entry.path().display().to_string())

    .collect::<Vec<String>>();

Dzięki zastosowaniu Iterator::filter i Iterator::map kod staje się bardziej przejrzysty, a dodawanie nowych filtrów staje się o wiele prostsze. Na przykład, łatwo możemy dodać nowy filtr według rozmiaru pliku lub daty ostatniej modyfikacji, co w poprzedniej wersji kodu mogło wymagać większych zmian.

Zaletą tego podejścia jest również bezpieczeństwo kompilacji, które zapewnia system typów w Rust. Dzięki temu, używając typu EntryType, możemy mieć pewność, że wszystkie możliwe warianty tego typu są odpowiednio obsłużone, a kompilator zwróci błąd, jeśli jakiś przypadek zostanie pominięty. Na przykład, jeśli w jednej z wersji kodu usuniemy przypadek obsługi pliku, kompilator natychmiast poinformuje nas o tym błędzie:

rust
Copy code
let type_filter = |entry: &DirEntry| {

    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(), // Błąd!
        })
};

Zmiana struktury kodu przy pomocy refaktoryzacji i użycie iteracji w Rust to kluczowe elementy pozwalające na utrzymanie wysokiej jakości kodu, zwłaszcza gdy projekt staje się coraz bardziej rozbudowany.

Testowanie wymaga także odpowiedniej obsługi różnych wyników w zależności od systemu operacyjnego, na którym uruchamiany jest program. W tym celu pomocna jest funkcja run, która uruchamia program z różnymi argumentami i porównuje wynik z oczekiwanym wyjściem zapisanym w pliku. Jest to sposób, który zapewnia pewność, że zmiany w kodzie nie wprowadziły nowych błędów:

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

    let file = format_file_name(expected_file);
    let contents = fs::read_to_string(file.as_ref())?;

    let mut expected: Vec<&str> = contents.split("\n").filter(|s| !s.is_empty()).collect();

    expected.sort();
    let cmd = Command::cargo_bin(PRG)?.args(args).assert().success();
    let out = cmd.get_output();
    let stdout = String::from_utf8(out.stdout.clone())?;

    let mut lines: Vec<&str> = stdout.split("\n").filter(|s| !s.is_empty()).collect();

    lines.sort();
    assert_eq!(lines, expected);
    Ok(())
}

Dzięki takim praktykom możemy utrzymać wysoką jakość kodu, zapewniając jego łatwą rozbudowę i utrzymanie.

Jak zaimplementować argumenty w programie w języku Rust?

Podczas tworzenia programu w języku Rust, który naśladuje działanie klasycznego narzędzia cut, ważnym krokiem jest odpowiednie zaimplementowanie obsługi argumentów. Program ten wymaga definiowania i walidacji danych wejściowych, takich jak pliki do przetworzenia, delimitery pól, czy też zakresy do wycięcia. Użycie biblioteki clap jest jednym z najwygodniejszych sposobów do realizacji tego zadania, a poniżej przedstawiamy kroki, jak skonstruować odpowiednią obsługę argumentów.

Przede wszystkim, do realizacji projektu wymagane są pewne zewnętrzne zależności, które należy dodać do pliku Cargo.toml:

toml
Copy code
[dependencies]
anyhow = "1.0.79"
clap = { version = "4.5.0", features = ["derive"] }
csv = "1.3.0"
regex = "1.10.3"
[dev-dependencies]
assert_cmd = "2.0.13"
predicates = "3.0.4"
pretty_assertions = "1.4.0"
rand = "0.8.5"

Definiowanie argumentów programu

Program będzie obsługiwał trzy kluczowe opcje, z których użytkownik musi wybrać jedną, a mianowicie:

• --fields (lub -f) – do określenia wybranych pól,

• --bytes (lub -b) – do określenia wybranych bajtów,

• --chars (lub -c) – do określenia wybranych znaków.

Korzystając z biblioteki clap, możemy zdefiniować strukturę, która będzie zawierała te argumenty. Do implementacji użyjemy struktury Args, która przechowa pliki wejściowe, separator, oraz informacje o tym, które dane mają zostać wycięte.

rust
Copy code
#[derive(Debug)]
struct Args {
    files: Vec<String>,
    delimiter: String,
    extract: ArgsExtract,
}
#[derive(Debug)]
struct ArgsExtract {
    fields: Option<String>,
    bytes: Option<String>,
    chars: Option<String>,
}

Konfiguracja clap i parsowanie argumentów

Aby skonfigurować clap w wersji opartej na derive, stworzymy odpowiednią strukturę, która automatycznie utworzy wymagany interfejs wiersza poleceń. Użyjemy do tego ArgsExtract, który będzie zawierał szczegóły dotyczące tego, co chcemy wyciąć. Warto także zaznaczyć, że wszystkie te opcje mogą przyjmować wartości domyślne, takie jak separator tabulatora (\t) dla -d lub -f.

rust
Copy code
#[derive(Debug, Parser)]
#[command(author, version, about)]
struct Args {
    #[arg(default_value = "-")]
    files: Vec<String>,
    #[arg(short, long, value_name = "DELIMITER", default_value = "\t")]
    delimiter: String,
    #[command(flatten)]
    extract: ArgsExtract,
}
#[derive(Debug, clap::Args)]
#[group(required = true, multiple = false)]
struct ArgsExtract {
    #[arg(short, long, value_name = "FIELDS")]
    fields: Option<String>,
    #[arg(short, long, value_name = "BYTES")]
    bytes: Option<String>,
    #[arg(short, long, value_name = "CHARS")]
    chars: Option<String>,
}

Walidacja argumentów

Po poprawnym skonfigurowaniu argumentów, ważnym krokiem jest ich walidacja. Jeśli użytkownik nie poda wymaganej opcji fields, bytes lub chars, program powinien zwrócić odpowiedni błąd. Program może także przeprowadzić dodatkowe sprawdzenie, np. czy separator został prawidłowo ustawiony, czy pliki wejściowe są dostępne, a także czy wybrany typ danych (pola, bajty, znaki) nie koliduje ze sobą.

Przykład uruchomienia programu z poprawnymi danymi:

bash
Copy code
$ cargo run -- -f 1
Args {
    files: ["-"],
    delimiter: "\t",
    extract: ArgsExtract {
        fields: Some("1"),
        bytes: None,
        chars: None,
    },
}

Jeśli użytkownik poda dwa konflikujące argumenty, np. -f i -b, program zwróci błąd:

bash
Copy code
$ cargo run -- -f 1 -b 8-9

error: the argument '--fields' cannot be used with '--bytes'
Usage: cutr <--fields |--bytes |--chars> [FILES]...

Zakończenie implementacji

Ostatecznie, ważnym krokiem jest zbudowanie testów, które sprawdzą poprawność działania programu. Testowanie takich aplikacji jest niezbędnym elementem zapewnienia stabilności, zwłaszcza gdy program zaczyna obsługiwać pliki w różnych formatach. Testy powinny obejmować zarówno poprawne, jak i błędne przypadki, aby upewnić się, że program działa zgodnie z oczekiwaniami w każdej sytuacji.

Endtext

Jak wykorzystać narzędzie comm do porównywania plików?

Narzędzie comm w systemach Unix jest jednym z najprostszych, ale zarazem bardzo użytecznych narzędzi do porównywania dwóch posortowanych plików tekstowych. Jego działanie opiera się na porównaniu linii w dwóch plikach, prezentując wyniki w trzech kolumnach: linie unikalne dla pierwszego pliku, linie unikalne dla drugiego pliku oraz linie wspólne dla obu plików. Istnieje jednak wiele dodatkowych opcji, które pozwalają na dokładniejsze dostosowanie wyników porównania, takich jak możliwość ignorowania wielkości liter, a także możliwość zmiany separatora kolumn.

Podstawowe opcje komendy comm obejmują:

• -1 – tłumienie pierwszej kolumny, czyli linii unikalnych dla pierwszego pliku,

• -2 – tłumienie drugiej kolumny, czyli linii unikalnych dla drugiego pliku,

• -3 – tłumienie trzeciej kolumny, czyli linii wspólnych,

• -i – porównanie niezależne od wielkości liter,

• --output-delimiter=STR – określenie niestandardowego separatora między kolumnami (domyślnie tabulator),

• -z – użycie zakończenia linii w postaci NUL zamiast nowej linii.

Przykłady zastosowania

Weźmy przykład z życia codziennego: mamy dwa pliki zawierające listy miast, w których odbyły się koncerty naszego ulubionego zespołu. Pierwszy plik zawiera miasta z poprzedniej trasy, a drugi – z obecnej. Aby znaleźć miasta, które zostały odwiedzone podczas obu tras, możemy użyć komendy comm z opcją -12, co oznacza, że chcemy wyświetlić tylko wspólne linie (miasta, które pojawiły się w obu plikach). Przykład:

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

Wynikiem będą miasta, które pojawiły się w obu trasach, np.:

nginx
Copy code
Boston

Cincinnati
Denton

Jeśli natomiast chcemy znaleźć tylko te miasta, które zostały odwiedzone wyłącznie podczas pierwszej trasy, należy użyć opcji -23, która tłumi drugą i trzecią kolumnę:

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

Wynikiem będą miasta, które zostały odwiedzone wyłącznie w pierwszej trasie, np.:

nginx
Copy code
Jackson

Santa Fe
Tucson

Z kolei, aby znaleźć miasta, które pojawiły się tylko w drugiej trasie, użyjemy opcji -13, która tłumi pierwszą i trzecią kolumnę:

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

Wynikiem będą miasta, które zostały odwiedzone wyłącznie w drugiej trasie:

nginx
Copy code
Denver

San Francisco
Ypsilanti

Zastosowanie w bioinformatyce

Choć przykład z miastami może wydawać się trywialny, narzędzie comm znajduje swoje miejsce także w bardziej zaawansowanych dziedzinach, takich jak bioinformatyka. W tej dziedzinie często porównuje się duże zbiory danych, np. sekwencje białek, które zostały pogrupowane w różne klastry. Przy pomocy comm możemy porównać sekwencje białek, które zostały pogrupowane w klastrach, z oryginalną listą sekwencji, aby znaleźć te, które nie zostały pogrupowane. Tego typu analiza pozwala na wykrycie potencjalnych białek o unikalnych właściwościach, które mogą wymagać dalszego badania.

Opcja porównania bez uwzględniania wielkości liter

W wersji BSD narzędzia comm istnieje możliwość przeprowadzenia porównań, które ignorują wielkość liter, za pomocą opcji -i. Działa to na przykład w przypadkach, gdy chcemy porównać teksty, które mogą zawierać różne zapisy liter (małe/duże litery), ale same treści są takie same. Na przykład:

bash
Copy code
comm -i -12 <(sort cities1_lower.txt) <(sort cities2_upper.txt)

Wynikiem będą miasta, które występują w obu plikach, niezależnie od tego, czy są zapisane małymi, czy dużymi literami.

Wskazówki do implementacji wersji Rust

Wersja narzędzia comm w języku Rust, nazwana commr, może być tworzona przy użyciu popularnych bibliotek, takich jak clap do obsługi argumentów wiersza poleceń i anyhow do obsługi błędów. Podstawowa struktura argumentów powinna zawierać informacje o dwóch plikach wejściowych, możliwościach tłumienia kolumn oraz ewentualnych opcjach takich jak porównanie niezależne od wielkości liter. Implementacja może zaczynać się od zdefiniowania struktury Args i obsługi odpowiednich argumentów w funkcji get_args.

Co warto dodać?

Ważnym elementem korzystania z narzędzi porównujących pliki jest świadomość, że dla poprawności wyników kluczowe jest prawidłowe przygotowanie danych wejściowych – muszą być one odpowiednio posortowane. W przypadku dużych zbiorów danych może się okazać, że dodatkowe optymalizacje, takie jak efektywne zarządzanie pamięcią podczas sortowania, będą miały kluczowe znaczenie. Również znajomość różnych opcji dostosowujących sposób porównywania, takich jak uwzględnianie wielkości liter czy zmiana separatorów, może pomóc w precyzyjnym dostosowaniu wyników analizy do indywidualnych potrzeb. Praktyczne zastosowanie komendy comm wykracza poza proste porównania tekstów, mając szerokie zastosowanie w analizach biologicznych, porównywaniu wyników badań oraz optymalizacji procesów przetwarzania danych w naukach przyrodniczych.

Jak zbudować program w Rust z obsługą argumentów, losowym wyborem i wzorcami

Tworzenie programu w Rust, który przetwarza argumenty wiersza poleceń, obsługuje losowe wybory na podstawie zadanych nasion i używa wyrażeń regularnych, może wydawać się skomplikowane, ale dzięki odpowiednim narzędziom, takim jak biblioteka clap, jest to stosunkowo proste. Program "fortuner" – wersja w Rust oryginalnej aplikacji fortune – jest doskonałym przykładem na wykorzystanie tych technik.

Zaczynamy od utworzenia nowego projektu w Rust za pomocą komendy:

bash
Copy code
cargo new fortuner

Następnie dodajemy do pliku Cargo.toml odpowiednie zależności:

toml
Copy code
[dependencies]
anyhow = "1.0.79"
clap = { version = "4.5.0", features = ["derive"] }
rand = "0.8.5"
regex = "1.10.3"
walkdir = "2.4.0"
[dev-dependencies]
assert_cmd = "2.0.13"
predicates = "3.0.4"
pretty_assertions = "1.4.0"

Po skonfigurowaniu zależności, kopiujemy katalog 12_fortuner/tests z książki do naszego projektu i uruchamiamy testy:

bash
Copy code
cargo test

Wszystkie testy powinny początkowo zakończyć się niepowodzeniem, ale to tylko część procesu tworzenia aplikacji. Celem jest teraz zdefiniowanie argumentów, które program będzie przyjmował.

Definicja Argumentów

Aby zdefiniować argumenty w naszym programie, zaczynamy od stworzenia struktury Args:

rust
Copy code
#[derive(Debug)]
pub struct Args {
    sources: Vec<String>,
    pattern: Option<String>,
    insensitive: bool,
    seed: Option<u64>,
}

W pliku main.rs definiujemy funkcję get_args(), która przy pomocy biblioteki clap będzie analizować argumenty wiersza poleceń:

rust
Copy code
fn get_args() -> Args {

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

        .version("0.1.0")
        .author("Ken Youens-Clark")
        .about("Rust version of `fortune`")
        .get_matches();
    Args {
        sources: ...,
        seed: ...,
        pattern: ...,
        insensitive: ...,
    }
}

Teraz możemy wywołać funkcję get_args() w main() i wydrukować przekazane argumenty:

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

Wynik powinien wyglądać mniej więcej tak:

bash
Copy code
$ cargo run -- -h

Rust version of `fortune`
Usage: fortuner [OPTIONS] ...
Arguments:
    ...    Input files or directories
Options:
    -m, --pattern      Pattern
    -i, --insensitive  Case-insensitive pattern matching
    -s, --seed         Random seed
    -h, --help         Print help
    -V, --version      Print version

Program powinien wymagać przynajmniej jednego pliku lub katalogu jako argumentu. Jeśli nie zostanie podany, program powinien zakończyć działanie, wyświetlając komunikat o błędzie:

bash
Copy code
$ cargo run
error: the following required arguments were not provided: ...
Usage: fortuner ...
For more information, try '--help'.

Walidacja Argumentów

bash
Copy code
$ cargo run -- ./tests/inputs -s blargh

error: invalid value 'blargh' for '--seed': invalid digit found in string

Generowanie Liczb Losowych

W tej aplikacji, aby uzyskać "losowy" wybór, używamy pseudolosowego generatora liczb (PRNG). Generowanie liczb losowych w komputerze nie jest rzeczywiście losowe, ale deterministyczne, co oznacza, że przy tym samym nasieniu zawsze uzyskamy te same wyniki. To właśnie daje możliwość testowania pseudolosowych programów – można używać tego samego nasienia do uzyskania przewidywalnych wyników. W tym przypadku wykorzystujemy bibliotekę rand do tworzenia PRNG.

Nasiono (seed) możemy przekazać przez argument -s i używać go do generowania tych "losowych" wyborów. Jeśli nasiono nie jest podane, program będzie korzystać z innego źródła losowości, dzięki czemu wybory będą wydawać się przypadkowe.

Obsługa Wyrażeń Regularnych

Kolejną istotną częścią jest obsługa wzorców za pomocą wyrażeń regularnych. Dzięki wyrażeniom regularnym możemy filtrować dane na podstawie różnych kryteriów. Aby umożliwić niewrażliwość na wielkość liter, używamy regex::RegexBuilder z opcją case_insensitive, która sprawia, że dopasowania są ignorujące wielkość liter.

W funkcji run możemy tworzyć wyrażenie regularne na podstawie podanego wzorca:

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

    let pattern = args
        .pattern
        .map(|val: String| {
            RegexBuilder::new(val.as_str())
                .case_insensitive(args.insensitive)
                .build()
                .map_err(|_| anyhow!(r#"Invalid --pattern "{val}""#))
        })
        .transpose()?;
    println!("{pattern:?}");
    Ok(())
}

Wartość args.pattern jest opcjonalna, więc musimy odpowiednio obsłużyć przypadek, w którym użytkownik jej nie podał. Jeśli podano niewłaściwy wzorzec, należy zgłosić błąd.

Ważne Aspekty, Które Należy Zrozumieć

Tworzenie programu, który operuje na plikach, używa wyrażeń regularnych i generuje pseudolosowe wyniki, wymaga uwagi na kilka kluczowych kwestii:

1. Dokładność Argumentów – Każdy argument powinien być odpowiednio walidowany, zwłaszcza przy przekazywaniu wartości, takich jak nasiono, które musi być liczbą całkowitą. Niewłaściwe dane wejściowe, jak np. niepoprawny typ, mogą prowadzić do błędów w działaniu programu.

2. Zrozumienie PRNG – Warto wiedzieć, że generator liczb losowych w komputerze nie jest naprawdę losowy. Przy takim podejściu należy zachować ostrożność, zwłaszcza w kontekście testowania oprogramowania, ponieważ ten sam seed zawsze wygeneruje te same wyniki.

3. Obsługa Wyrażeń Regularnych – Dobre zrozumienie wyrażeń regularnych jest kluczowe, szczególnie gdy chcemy dodać elastyczność do aplikacji, pozwalając użytkownikowi na dopasowanie wzorców do tekstu w różnych formach.

4. Testowanie – Aby upewnić się, że aplikacja działa prawidłowo, warto dodać odpowiednie testy jednostkowe, które sprawdzą, czy poprawnie obsługujemy różne przypadki, takie jak błędne dane wejściowe czy brak argumentów.