Решение на CSV Filter от Лъчезар Младенов

Обратно към всички решения

Към профила на Лъчезар Младенов

Код

use std::io::Write;

use std::collections::HashMap;

use std::collections::HashSet;

use std::io::BufRead;

type Row = HashMap<String, String>;

/// Проверява че следващия символ във входния низ `input` е точно `target`.

///

/// Ако низа наистина започва с този символ, връща остатъка от низа без него, пакетиран във

/// `Some`. Иначе, връща `None`. Примерно:

///

/// skip_next("(foo", '(') //=> Some("foo")

/// skip_next("(foo", ')') //=> None

/// skip_next("", ')') //=> None

///

pub fn skip_next(input: &str, target: char) -> Option<&str> {

if input.chars().nth(0) == Some(target) {

Some( &input[1..] )

} else {

None

}

}

/// Търси следващото срещане на символа `target` в низа `input`. Връща низа до този символ и низа

/// от този символ нататък, в двойка.

///

/// Ако не намери `target`, връща оригиналния низ и празен низ като втори елемент в двойката.

///

/// take_until(" foo/bar ", '/') //=> (" foo", "/bar ")

/// take_until("foobar", '/') //=> ("foobar", "")

///

pub fn take_until(input: &str, target: char) -> (&str, &str) {

for (i, c) in input.chars().enumerate() {

if c == target {

return ( &input[0..i], &input[i..] )

}

}

(&input, "")

}

/// Комбинация от горните две функции -- взема символите до `target` символа, и връща частта преди

/// символа и частта след, без самия символ. Ако символа го няма, връща `None`.

///

/// take_and_skip(" foo/bar ", '/') //=> Some((" foo", "bar "))

/// take_and_skip("foobar", '/') //=> None

///

pub fn take_and_skip(input: &str, target: char) -> Option<(&str, &str)> {

let pair = take_until(input, target);

let next = skip_next(pair.1, target);

if next == None {

None

} else {

Some( ( pair.0, next.unwrap() ) )

}

}

#[derive(Debug)]

pub enum CsvError {

IO(std::io::Error),

ParseError(String),

InvalidHeader(String),

InvalidRow(String),

InvalidColumn(String),

}

pub struct Csv<R: BufRead> {

pub columns: Vec<String>,

reader: R,

selection: Option<Box<dyn Fn(&Row) -> Result<bool, CsvError>>>,

}

impl<R: BufRead> Csv<R> {

/// Конструира нова стойност от подадения вход. Третира се като "нещо, от което може да се чете

/// ред по ред".

///

/// Очакваме да прочетете първия ред от входа и да го обработите като заглавна част ("header").

/// Това означава, че първия ред би трябвало да включва имена на колони, разделени със

/// запетайки и може би празни места. Примерно:

///

/// - name, age

/// - name,age,birth date

///

/// В случай, че има грешка от викане на методи на `reader`, тя би трябвало да е `io::Error`.

/// върнете `CsvError::IO`, което опакова въпросната грешка.

///

/// Ако първия ред е празен, прочитането ще ви върне 0 байта. Примерно, `read_line` връща

/// `Ok(0)` в такъв случай. Това означава, че нямаме валиден header -- нито една колона няма,

/// очакваме грешка `CsvError::InvalidHeader`.

///

/// Ако има дублиране на колони -- две колони с едно и също име -- също върнете

/// `CsvError::InvalidHeader`.

///

/// Ако всичко е наред, върнете конструирана стойност, на която `columns` е списък с колоните,

/// в същия ред, в който са подадени, без заобикалящите ги празни символи (използвайте

/// `.trim()`).

///

pub fn new(mut reader: R) -> Result<Self, CsvError> {

let mut line = String::new();

match reader.read_line(&mut line) {

Ok(0) => return Err( CsvError::InvalidHeader("No header".to_string()) ),

Ok(l) => l,

Err(e) => return Err(CsvError::IO(e)),

};

// TODO use take_until

let split = line.split(',');

let mut columns = Vec::new();

let mut set = HashSet::new();

for s in split {

if !set.insert(s.trim().to_string()) {

return Err( CsvError::InvalidHeader("Duplicate header column".to_string()) );

}

columns.push(s.trim().to_string());

}

Ok( Csv { columns, reader, selection: Some( Box::new(|_| Ok(true)) ) } )

}

/// Функцията приема следващия ред за обработка и конструира `Row` стойност

/// (`HashMap<String, String>`) със колоните и съответсващите им стойности на този ред.

///

/// Алгоритъма е горе-долу:

///

/// 1. Изчистете реда с `.trim()`.

/// 2. Очаквате, че реда ще започне със `"`, иначе връщате грешка.

/// 3. Прочитате съдържанието от отварящата кавичка до следващата. Това е съдържанието на

/// стойността на текущата колона на този ред. Не го чистите от whitespace, просто го

/// приемате както е.

/// 4. Ако не намерите затваряща кавичка, това е грешка.

/// 5. Запазвате си стойността в един `Row` (`HashMap`) -- ключа е името на текущата колона,

/// до която сте стигнали, стойността е това, което току-що изпарсихте.

/// 6. Ако нямате оставащи колони за обработка и нямате оставащо съдържание от реда, всичко

/// е ок. Връщате реда.

/// 7. Ако нямате оставащи колони, но имате още от реда, или обратното, това е грешка.

///

/// За този процес, помощните функции, които дефинирахме по-горе може да ви свършат работа.

/// *Може* да използвате вместо тях `.split` по запетайки, но ще имаме поне няколко теста със

/// вложени запетайки. Бихте могли и с това да се справите иначе, разбира се -- ваш избор.

///

/// Внимавайте с празното пространство преди и след запетайки -- викайте `.trim()` на ключови

/// места. Всичко в кавички се взема както е, всичко извън тях се чисти от whitespace.

///

/// Всички грешки, които ще връщате, се очаква да бъдат `CsvError::InvalidRow`.

///

pub fn parse_line(&mut self, line: &str) -> Result<Row, CsvError> {

let mut line: &str = line.trim();

let mut row: Row = Row::new();

let mut i = 0;

let size = self.columns.len();

while i < size {

line = line.trim();

line = match skip_next(line, '"') {

Some(s) => s,

None => return Err( CsvError::InvalidRow("Invalid format".to_string()) ),

};

let result = match take_and_skip(line, '"') {

Some((a, b)) => (a, b),

None => return Err( CsvError::InvalidRow("Invalid format".to_string()) ),

};

line = result.1.trim();

row.insert(self.columns[i].to_string(), result.0.to_string());

i += 1;

if i != size {

line = match skip_next(line, ',') {

Some(s) => s.trim(),

None => return Err( CsvError::InvalidRow("Invalid format".to_string()) ),

};

}

}

if line.len() != 0 {

return Err( CsvError::InvalidRow("Invalid format".to_string()) );

}

Ok(row)

}

/// Подадената функция, "callback", се очаква да се запази и да се използва по-късно за

/// филтриране -- при итерация, само редове, за които се връща `true` се очаква да се извадят.

///

/// Би трябвало `callback` да се вика от `.next()` и от `.write_to()`, вижте описанията на тези

/// методи за детайли.

///

pub fn apply_selection<F>(&mut self, callback: F)

where F: Fn(&Row) -> Result<bool, CsvError> + 'static

{

self.selection = Some( Box::new( callback ) )

}

/// Извикването на този метод консумира CSV-то и записва филтрираното съдържание в подадената

/// `Write` стойност. Вижте по-долу за пример и детайли.

///

/// Грешките, които се връщат са грешките, които идват от използваните други методи, плюс

/// грешките от писане във `writer`-а, опаковани в `CsvError::IO`.

///

/// В зависимост от това как си имплементирате метода, `mut` може би няма да ви трябва за

/// `self` -- ако имате warning-и, просто го махнете.

///

pub fn write_to<W: Write>(mut self, mut writer: W) -> Result<(), CsvError> {

match writeln!(writer, "{}", self.columns.join(", ")) {

Err(e) => return Err( CsvError::IO(e) ),

Ok(_) => (),

};

let len = self.columns.len();

while let Some(row) = self.next() {

for (i, col) in self.columns.iter().enumerate() {

match write!(writer, "\"{}\"", row.as_ref().unwrap().get(col.as_str()).unwrap()) {

Err(e) => return Err( CsvError::IO(e) ),

Ok(_) => (),

};

if i + 1 != len {

match write!(writer, ", ") {

Err(e) => return Err( CsvError::IO(e) ),

Ok(_) => (),

};

}

}

match writeln!(writer, "") {

Err(e) => return Err( CsvError::IO(e) ),

Ok(_) => (),

};

}

Ok(())

}

}

impl<R: BufRead> Iterator for Csv<R> {

type Item = Result<Row, CsvError>;

/// Итерацията се състои от няколко стъпки:

///

/// 1. Прочитаме следващия ред от входа:

/// -> Ако има грешка при четене, връщаме Some(CsvError::IO(...))

/// -> Ако успешно се прочетат 0 байта, значи сме на края на входа, и няма какво повече да

/// четем -- връщаме `None`

/// -> Иначе, имаме успешно прочетен ред, продължаваме напред

/// 2. Опитваме се да обработим прочетения ред със `parse_line`:

/// -> Ако има грешка при парсене, връщаме Some(CsvError-а, който се връща от `parse_line`)

/// -> Ако успешно извикаме `parse_line`, вече имаме `Row` стойност.

/// 3. Проверяваме дали този ред изпълнява условието, запазено от `apply_selection`:

/// -> Ако условието върне грешка, връщаме тази грешка опакована във `Some`.

/// -> Ако условието върне Ok(false), *не* връщаме този ред, а пробваме следващия (обратно

/// към стъпка 1)

/// -> При Ok(true), връщаме този ред, опакован във `Some`

///

/// Да, тази функция връща `Option<Result<...>>` :). `Option` защото може да има, може да няма

/// следващ ред, `Result` защото четенето на реда (от примерно файл) може да не сработи.

///

fn next(&mut self) -> Option<Self::Item> {

let mut line= String::new();

loop {

match self.reader.read_line(&mut line) {

Ok(0) => return None,

Ok(l) => l,

Err(e) => return Some(Err(CsvError::IO(e))),

};

let row: Row = match self.parse_line(line.as_str()) {

Err(e) => return Some(Err(e)),

Ok(r) => r,

};

match (self.selection.as_ref().unwrap())(&row) {

Ok(true) => return Some(Ok(row)),

Err(e) => return Some(Err(e)),

_ => (),

}

}

}

}

Лог от изпълнението

Compiling solution v0.1.0 (/tmp/d20210111-1538662-1cdpscr/solution)
    Finished test [unoptimized + debuginfo] target(s) in 4.36s
     Running target/debug/deps/solution_test-8916805fc40a2dab

running 15 tests
test solution_test::test_csv_basic ... ok
test solution_test::test_csv_duplicate_columns ... ok
test solution_test::test_csv_empty ... ok
test solution_test::test_csv_iterating_with_a_selection ... FAILED
test solution_test::test_csv_iterating_with_no_selection ... ok
test solution_test::test_csv_parse_line ... ok
test solution_test::test_csv_parse_line_with_commas ... ok
test solution_test::test_csv_selection_and_writing ... FAILED
test solution_test::test_csv_single_column_no_data ... ok
test solution_test::test_csv_writing_without_a_selection ... ok
test solution_test::test_csv_writing_without_any_rows ... ok
test solution_test::test_parsing_helpers_for_unicode ... FAILED
test solution_test::test_skip_next ... ok
test solution_test::test_take_and_skip ... FAILED
test solution_test::test_take_until ... FAILED

failures:

---- solution_test::test_csv_iterating_with_a_selection stdout ----
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: InvalidRow("Invalid format")', tests/solution_test.rs:218:44
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

---- solution_test::test_csv_selection_and_writing stdout ----
thread '<unnamed>' panicked at 'called `Result::unwrap()` on an `Err` value: InvalidRow("Invalid format")', /tmp/d20210111-1538662-1cdpscr/solution/src/lib.rs:220:61
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: InvalidRow("Invalid format")', tests/solution_test.rs:251:5

---- solution_test::test_parsing_helpers_for_unicode stdout ----
thread 'main' panicked at 'byte index 1 is not a char boundary; it is inside '↓' (bytes 0..3) of `↓яга`', src/lib.rs:19:16

---- solution_test::test_take_and_skip stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `None`,
 right: `Some(("баба", "яга"))`', tests/solution_test.rs:128:5

---- solution_test::test_take_until stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `("ба", "ба/яга")`,
 right: `("баба", "/яга")`', tests/solution_test.rs:121:5


failures:
    solution_test::test_csv_iterating_with_a_selection
    solution_test::test_csv_selection_and_writing
    solution_test::test_parsing_helpers_for_unicode
    solution_test::test_take_and_skip
    solution_test::test_take_until

test result: FAILED. 10 passed; 5 failed; 0 ignored; 0 measured; 0 filtered out

error: test failed, to rerun pass '--test solution_test'

История (1 версия и 0 коментара)