Решение на CSV Filter от Християна Панайотова

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

Към профила на Християна Панайотова

Код

#[derive(Debug)]

pub enum CsvError {

IO(std::io::Error),

ParseError(String),

InvalidHeader(String),

InvalidRow(String),

InvalidColumn(String),

}

use std::{collections::HashMap, io::BufReader, vec};

type Row = HashMap<String, String>;

use std::io::BufRead;

use std::io::Write;

fn crop_letters(s: &str, pos: usize) -> &str {

match s.char_indices().skip(pos).next() {

Some((pos, _)) => &s[pos..],

None => "",

}

}

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

let mut chars = input.chars();

if input.len() == 0 || target != chars.next().unwrap() {

None

} else {

let cropped = crop_letters(input, 1);

Some(cropped)

}

}

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

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

///

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

///

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

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

///

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

let mut has_reached_target = false;

let mut index = 0;

for c in input.chars() {

if c == target && !has_reached_target {

has_reached_target = true;

break;

}

index = index + 1;

}

if !has_reached_target {

(input, "")

} else {

(&input[..index], &input[index..])

}

}

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

let val = skip_next(second, target);

match val {

None => None,

Some(ref x) => Some((first, x)),

}

}

pub fn parse_header(mut header: String) -> Result<Vec<String>, CsvError> {

header = String::from(header.trim());

if header.len() == 0 {

return Err(CsvError::InvalidHeader(String::from(

"The provided header is empty!",

)));

}

let mut header_elems: Vec<String> = vec![];

let mut split = take_and_skip(&header, ',');

loop {

let (mut first, second) = split.unwrap();

first = first.trim();

let val = String::from(first);

if header_elems.contains(&val) {

return Err(CsvError::InvalidHeader(String::from(

"Duplicate header elements!",

)));

}

header_elems.push(val);

split = take_and_skip(second, ',');

if split == None {

header_elems.push(String::from(second.trim()));

break;

}

}

Ok(header_elems)

}

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

let res = reader.read_line(&mut buffer);

match res {

Err(e) => Err(CsvError::IO(e as std::io::Error)),

Ok(_) => {

let val = parse_header(buffer);

match val {

Err(e) => Err(e),

Ok(v) => Ok(Csv {

reader: reader,

columns: v,

selection: None,

}),

}

}

}

}

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

let mut trimmed_line = line.trim();

let mut values: Vec<String> = vec![];

loop {

let mut val = skip_next(&trimmed_line, '"');

if val == None {

return Err(CsvError::InvalidRow(String::from(

"Invalid row syntax - missing quotation mark!",

)));

}

let partition_res = take_and_skip(val.unwrap(), '"');

if partition_res == None {

return Err(CsvError::InvalidRow(String::from(

"Invalid row syntax - missing end quotation mark!",

)));

}

let (first, second) = partition_res.unwrap();

values.push(String::from(first));

trimmed_line = second.trim();

if trimmed_line == "" {

break;

}

val = skip_next(&trimmed_line, ',');

if val == None {

return Err(CsvError::InvalidRow(String::from(

"Invalid row syntax - missing ,!",

)));

}

trimmed_line = val.unwrap().trim();

}

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

return Err(CsvError::InvalidRow(String::from(

"The size of the rows and columns does not match!",

)));

}

let mut iters = values.iter();

let mut iter = iters.next();

for key in &self.columns {

map.insert(String::from(key), String::from(iter.unwrap()));

iter = iters.next();

}

Ok(map)

}

/// Подадената функция, "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));

}

pub fn get_parsed_new_line(&mut self) -> Option<Result<Row, CsvError>> {

let mut buffer = String::new();

let res = self.reader.read_line(&mut buffer);

match res {

Err(e) => Some(Err(CsvError::IO(e as std::io::Error))),

Ok(bytes_read) => {

if bytes_read == 0 {

return None;

}

let row_result = self.parse_line(&buffer);

match row_result {

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

Ok(row) => match self.selection {

Some(ref val) => {

let value = (*val)(&row);

match value {

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

Ok(value) => {

if value {

return Some(Ok(row));

} else {

return self.get_parsed_new_line();

}

}

}

}

None => Some(Ok(row)),

},

}

}

}

}

pub fn build_row(&mut self, row: Row) -> String {

let mut str = String::from("\n");

let mut is_first = true;

for key in &self.columns {

if !is_first {

str.push_str(", ")

}

let value = row.get(key).unwrap();

str = str + "\"" + value + "\"";

is_first = false;

}

str

}

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

loop {

let val = self.get_parsed_new_line();

match val {

None => {

return Ok(());

}

Some(val) => match val {

Err(e) => {

return Err(e);

}

Ok(row) => match writer.write(self.build_row(row).as_bytes()) {

Err(e) => {

return Err(CsvError::IO(e as std::io::Error));

}

Ok(_) => {

return self.write_helper(writer);

}

},

},

}

}

}

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

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

///

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

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

///

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

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

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

let mut str = String::from("");

let mut is_first = true;

for key in &self.columns {

if !is_first {

str.push_str(", ")

}

str = str + key;

is_first = false;

}

match writer.write(str.as_bytes()) {

Err(e) => {

return Err(CsvError::IO(e as std::io::Error));

}

Ok(_) => self.write_helper(writer),

}

}

}

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> {

self.get_parsed_new_line()

}

}

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

Compiling solution v0.1.0 (/tmp/d20210111-1538662-14e89lv/solution)
warning: unused import: `io::BufReader`
  --> src/lib.rs:10:33
   |
10 | use std::{collections::HashMap, io::BufReader, vec};
   |                                 ^^^^^^^^^^^^^
   |
   = note: `#[warn(unused_imports)]` on by default

warning: 1 warning emitted

    Finished test [unoptimized + debuginfo] target(s) in 4.05s
     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 ... ok
test solution_test::test_csv_parse_line_with_commas ... ok
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 ... 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_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_single_column_no_data stdout ----
thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', src/lib.rs:94:41

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

---- 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_duplicate_columns
    solution_test::test_csv_single_column_no_data
    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 коментара)