Решение на CSV Filter от Владислав Георгиев

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

Към профила на Владислав Георгиев

Код

use std::io::BufRead;

use std::collections::HashMap;

use std::io::Write;

use std::io::Read;

use std::io::BufReader;

type Row = HashMap<String, String>;

use std::io::{Error, ErrorKind};

#[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 input = String::new();

let line = reader.read_line(&mut input);

match line {

Ok(_r) => {}

Err(e) => {

return Err(CsvError::IO(e));

}

}

if line.unwrap() == 0 {

return Err(CsvError::InvalidHeader(String::from("Invalid header!")));

};

if input == "" {

return Err(CsvError::InvalidHeader(String::from("Invalid header!")));

}

let mut header: Vec<String> = Vec::new();

let mut result = take_and_skip(&input, ',');

if result == None {

return Err(CsvError::InvalidHeader(String::from("Invalid header!")));

}

loop {

let (column, next) = result.unwrap();

header.push(column.trim().to_string());

result = take_and_skip(&next, ',');

if result == None {

let (last_input, _) = take_until(next, '\n');

if last_input == next || last_input == ""{

return Err(CsvError::InvalidHeader(String::from("Invalid header!")));

}

header.push(last_input.trim().to_string());

break;

}

}

let csv = Csv { columns: header, reader: reader, selection: None };

Ok(csv)

}

/// Функцията приема следващия ред за обработка и конструира `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 trimmed = line.trim();

if trimmed.chars().nth(0).unwrap() != '"' {

return Err(CsvError::InvalidRow(String::from("invalid row!")))

}

let mut result = take_and_skip(&line, '"');

let mut row_values: Vec<String> = Vec::new();

if result == None {

return Err(CsvError::InvalidRow(String::from("Invalid header!")));

}

loop {

let (mut row_raw, next) = result.unwrap();

//print!("{:?}\n", row_raw);

row_raw = row_raw.trim();

if row_raw != "" {

return Err(CsvError::InvalidRow(String::from("invalid row!")));

}

let (row_value, new_next) = take_until(&next, '"');

if new_next == "" {

return Err(CsvError::InvalidRow(String::from("Invalid row!")));

}

row_values.push(row_value.to_string());

let new_result = take_and_skip(&new_next[1..], ',');

if new_result == None {

break;

}

let (_, new_next) = new_result.unwrap();

result = take_and_skip(&new_next, '"');

}

if row_values.len() != self.columns.len() {

return Err(CsvError::InvalidRow(String::from("Invalid row!")));

}

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

for (idx, row_value) in row_values.iter().enumerate() {

row.insert(self.columns[idx].clone(), row_value.to_string());

}

return 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

{

let boxed : Box<F> = Box::new(callback);

self.selection = Some(boxed);

}

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

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

///

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

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

///

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

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

///

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

let mut joined_header = self.columns.join(", ");

joined_header += "\n";

let write_err = writer.write(joined_header.as_bytes());

match write_err {

Err(e) => {

return Err(CsvError::IO(e));

}

Ok(_) => {}

}

loop {

let line_result = self.next();

match line_result {

Some(v) => {

match v {

Ok(result) => {

let mut row = String::new();

for (idx, row_value) in self.columns.iter().enumerate() {

row += "\"";

row += &result[row_value];

row += "\"";

if idx != self.columns.len() - 1 {

row += ", ";

}

}

row += "\n";

let write_err = writer.write(row.as_bytes());

match write_err {

Err(e) => {

return Err(CsvError::IO(e));

}

Ok(_) => {}

}

}

Err(err) => {

return Err(err);

}

}

}

None => {

break;

}

}

}

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 next_line = String::new();

let len = self.reader.read_line(&mut next_line);

match len {

Ok(v) => {

if v == 0 {

return None;

}

let res = self.parse_line(&next_line);

match res {

Ok(v) => {

if self.selection.is_none() {

return Some(Ok(v));

}

let result = (self.selection.as_ref().unwrap())(&v);

match result {

Ok(return_row) => {

if return_row { return Some(Ok(v)) } else { return self.next() }

}

Err(e) => {

return Some(Err(e));

}

}

}

Err(e) => {

return Some(Err(e));

}

}

}

Err(e) => {

let error : Self::Item = Err(CsvError::IO(e));

return Some(error);

}

}

}

}

/// Проверява че следващия символ във входния низ `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) {

return Some(&input[1..]);

} else {

return None;

}

}

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

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

///

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

///

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

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

///

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

let index = input.find(target);

if index == None {

return (input, "");

}

return (&input[..index.unwrap()], &input[index.unwrap()..]);

}

/// Комбинация от горните две функции -- взема символите до `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 (first, second) = take_until(input, target);

if second == "" {

return None;

}

return Some((first, skip_next(second, target).unwrap()));

}

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

Compiling solution v0.1.0 (/tmp/d20210111-1538662-1jewfas/solution)
warning: unused import: `std::io::Read`
 --> src/lib.rs:4:5
  |
4 | use std::io::Read;
  |     ^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: unused import: `std::io::BufReader`
 --> src/lib.rs:5:5
  |
5 | use std::io::BufReader;
  |     ^^^^^^^^^^^^^^^^^^

warning: unused imports: `ErrorKind`, `Error`
 --> src/lib.rs:7:15
  |
7 | use std::io::{Error, ErrorKind};
  |               ^^^^^  ^^^^^^^^^

warning: 3 warnings emitted

    Finished test [unoptimized + debuginfo] target(s) in 4.09s
     Running target/debug/deps/solution_test-8916805fc40a2dab

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

failures:

---- solution_test::test_csv_duplicate_columns stdout ----
thread 'main' panicked at 'Expression None does not match the pattern "Some(CsvError::InvalidHeader(_))"', tests/solution_test.rs:92:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

---- solution_test::test_csv_parse_line stdout ----
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: InvalidHeader("Invalid header!")', tests/solution_test.rs:142:36

---- solution_test::test_csv_parse_line_with_commas stdout ----
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: InvalidHeader("Invalid header!")', tests/solution_test.rs:160:36

---- solution_test::test_csv_single_column_no_data stdout ----
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: InvalidHeader("Invalid header!")', tests/solution_test.rs:177:71

---- solution_test::test_csv_writing_without_any_rows stdout ----
thread '<unnamed>' panicked at 'called `Result::unwrap()` on an `Err` value: InvalidHeader("Invalid header!")', tests/solution_test.rs:283:36
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: InvalidHeader("Invalid header!")', tests/solution_test.rs:278: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:343:22


failures:
    solution_test::test_csv_duplicate_columns
    solution_test::test_csv_parse_line
    solution_test::test_csv_parse_line_with_commas
    solution_test::test_csv_single_column_no_data
    solution_test::test_csv_writing_without_any_rows
    solution_test::test_parsing_helpers_for_unicode

test result: FAILED. 9 passed; 6 failed; 0 ignored; 0 measured; 0 filtered out

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

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