X-Git-Url: http://git.scottworley.com/tablify/blobdiff_plain/70436f237f896aa7651ef259c16a19302e85df38..d9bfcf4d1b74bebfcc9881aad4f0aacd01238b01:/src/lib.rs diff --git a/src/lib.rs b/src/lib.rs index 370eb5d..c5761d8 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,8 +1,11 @@ -use std::collections::{HashMap, HashSet}; +use std::borrow::ToOwned; +use std::collections::HashMap; use std::fmt::Write; use std::io::BufRead; use std::iter::Iterator; +pub struct Config {} + const HEADER: &str = " @@ -75,35 +78,37 @@ impl std::fmt::Display for HTML { } } -#[derive(Debug, PartialEq, Eq, Hash)] -struct Entry { - col: String, - instance: Option, +#[derive(Debug, PartialEq, Eq)] +enum InputLine<'a> { + Blank, + RowHeader(&'a str), + Entry(&'a str, Option<&'a str>), } -impl From<&str> for Entry { - fn from(value: &str) -> Entry { - match value.split_once(':') { - None => Entry { - col: String::from(value), - instance: None, - }, - Some((col, instance)) => Entry { - col: String::from(col.trim()), - instance: Some(String::from(instance.trim())), - }, +impl<'a> From<&'a str> for InputLine<'a> { + fn from(value: &'a str) -> InputLine<'a> { + let trimmed = value.trim_end(); + if trimmed.is_empty() { + InputLine::Blank + } else if !trimmed.starts_with(' ') { + InputLine::RowHeader(value.trim()) + } else { + match value.split_once(':') { + None => InputLine::Entry(value.trim(), None), + Some((col, instance)) => InputLine::Entry(col.trim(), Some(instance.trim())), + } } } } #[derive(Debug, PartialEq, Eq)] -struct RowInput { +struct Row { label: String, - entries: Vec, + entries: HashMap>>, } struct Reader>> { input: std::iter::Enumerate, - row: Option, + row: Option, } impl>> Reader { fn new(input: Input) -> Self { @@ -114,60 +119,57 @@ impl>> Reader { } } impl>> Iterator for Reader { - type Item = Result; + type Item = Result; fn next(&mut self) -> Option { loop { - match self - .input - .next() - .map(|(n, r)| (n, r.map(|line| String::from(line.trim_end())))) - { + match self.input.next() { None => return Ok(std::mem::take(&mut self.row)).transpose(), Some((_, Err(e))) => return Some(Err(e)), - Some((_, Ok(line))) if line.is_empty() && self.row.is_some() => { - return Ok(std::mem::take(&mut self.row)).transpose() - } - Some((_, Ok(line))) if line.is_empty() => {} - Some((n, Ok(line))) if line.starts_with(' ') => match &mut self.row { - None => { - return Some(Err(std::io::Error::other(format!( - "{}: Entry with no header", - n + 1 - )))) + Some((n, Ok(line))) => match InputLine::from(line.as_ref()) { + InputLine::Blank if self.row.is_some() => { + return Ok(std::mem::take(&mut self.row)).transpose() } - Some(ref mut row) => row.entries.push(Entry::from(line.trim())), - }, - Some((_, Ok(line))) => { - let prev = std::mem::take(&mut self.row); - self.row = Some(RowInput { - label: line, - entries: vec![], - }); - if prev.is_some() { - return Ok(prev).transpose(); + InputLine::Blank => {} + InputLine::Entry(col, instance) => match &mut self.row { + None => { + return Some(Err(std::io::Error::other(format!( + "{}: Entry with no header", + n + 1 + )))) + } + Some(ref mut row) => { + row.entries + .entry(col.to_owned()) + .and_modify(|is| is.push(instance.map(ToOwned::to_owned))) + .or_insert_with(|| vec![instance.map(ToOwned::to_owned)]); + } + }, + InputLine::RowHeader(row) => { + let prev = std::mem::take(&mut self.row); + self.row = Some(Row { + label: row.to_owned(), + entries: HashMap::new(), + }); + if prev.is_some() { + return Ok(prev).transpose(); + } } - } + }, } } } } -fn read_rows(input: impl std::io::Read) -> impl Iterator> { +fn read_rows(input: impl std::io::Read) -> impl Iterator> { Reader::new(std::io::BufReader::new(input).lines()) } -fn column_counts(rows: &[RowInput]) -> Vec<(usize, String)> { +fn column_counts(rows: &[Row]) -> Vec<(usize, String)> { let mut counts: Vec<_> = rows .iter() - .flat_map(|r| { - r.entries - .iter() - .map(|e| &e.col) - .collect::>() - .into_iter() - }) + .flat_map(|r| r.entries.keys()) .fold(HashMap::new(), |mut cs, col| { - cs.entry(String::from(col)) + cs.entry(col.to_owned()) .and_modify(|n| *n += 1) .or_insert(1); cs @@ -178,45 +180,49 @@ fn column_counts(rows: &[RowInput]) -> Vec<(usize, String)> { counts.sort_unstable_by(|(an, acol), (bn, bcol)| bn.cmp(an).then(acol.cmp(bcol))); counts } -fn column_order(rows: &[RowInput]) -> Vec { +fn column_order(rows: &[Row]) -> Vec { column_counts(rows) .into_iter() .map(|(_, col)| col) .collect() } -fn render_instance(entry: &Entry) -> HTML { - match &entry.instance { +fn render_instance(instance: &Option) -> HTML { + match instance { None => HTML::from("✓"), Some(instance) => HTML::escape(instance.as_ref()), } } -fn render_cell(col: &str, row: &RowInput) -> HTML { +fn render_cell(col: &str, row: &mut Row) -> HTML { let row_label = HTML::escape(row.label.as_ref()); let col_label = HTML::escape(col); - let entries: Vec<&Entry> = row.entries.iter().filter(|e| e.col == col).collect(); - let class = HTML::from(if entries.is_empty() { "" } else { "yes" }); - let all_empty = entries.iter().all(|e| e.instance.is_none()); - let contents = if entries.is_empty() || (all_empty && entries.len() == 1) { + let instances: Option<&Vec>> = row.entries.get(col); + let class = HTML::from(if instances.is_none() { "" } else { "yes" }); + let all_empty = instances + .iter() + .flat_map(|is| is.iter()) + .all(Option::is_none); + let contents = if instances.is_none() || (all_empty && instances.unwrap().len() == 1) { HTML::from("") } else if all_empty { - HTML(format!("{}", entries.len())) + HTML(format!("{}", instances.unwrap().len())) } else { HTML( - entries + instances + .unwrap() .iter() - .map(|i| render_instance(i)) + .map(render_instance) .map(|html| html.0) // Waiting for slice_concat_trait to stabilize .collect::>() .join(" "), ) }; + row.entries.remove(col); HTML(format!("{contents}")) } -fn render_row(columns: &[String], row: &RowInput) -> HTML { - // This is O(n^2) & doesn't need to be +fn render_row(columns: &[String], row: &mut Row) -> HTML { let row_label = HTML::escape(row.label.as_ref()); HTML(format!( "{row_label}{}\n", @@ -249,14 +255,14 @@ fn render_column_headers(columns: &[String]) -> HTML { /// * there's an i/o error while reading `input` /// * the log has invalid syntax: /// * an indented line with no preceding non-indented line -pub fn tablify(input: impl std::io::Read) -> Result { +pub fn tablify(config: &Config, input: impl std::io::Read) -> Result { let rows = read_rows(input).collect::, _>>()?; let columns = column_order(&rows); Ok(HTML(format!( "{HEADER}{}{}{FOOTER}", render_column_headers(&columns), rows.into_iter() - .map(|r| render_row(&columns, &r)) + .map(|mut r| render_row(&columns, &mut r)) .collect::() ))) } @@ -266,27 +272,31 @@ mod tests { use super::*; #[test] - fn test_parse_entry() { + fn test_parse_line() { + assert_eq!(InputLine::from(""), InputLine::Blank); + assert_eq!(InputLine::from(" "), InputLine::Blank); + assert_eq!(InputLine::from("foo"), InputLine::RowHeader("foo")); + assert_eq!(InputLine::from("foo "), InputLine::RowHeader("foo")); + assert_eq!(InputLine::from(" foo"), InputLine::Entry("foo", None)); assert_eq!( - Entry::from("foo"), - Entry { - col: String::from("foo"), - instance: None - } + InputLine::from(" foo:bar"), + InputLine::Entry("foo", Some("bar")) ); assert_eq!( - Entry::from("foo:bar"), - Entry { - col: String::from("foo"), - instance: Some(String::from("bar")) - } + InputLine::from(" foo: bar"), + InputLine::Entry("foo", Some("bar")) ); assert_eq!( - Entry::from("foo: bar"), - Entry { - col: String::from("foo"), - instance: Some(String::from("bar")) - } + InputLine::from(" foo: bar "), + InputLine::Entry("foo", Some("bar")) + ); + assert_eq!( + InputLine::from(" foo: bar "), + InputLine::Entry("foo", Some("bar")) + ); + assert_eq!( + InputLine::from(" foo : bar "), + InputLine::Entry("foo", Some("bar")) ); } @@ -294,45 +304,48 @@ mod tests { fn test_read_rows() { assert_eq!( read_rows(&b"foo"[..]).flatten().collect::>(), - vec![RowInput { - label: String::from("foo"), - entries: vec![] + vec![Row { + label: "foo".to_owned(), + entries: HashMap::new(), }] ); assert_eq!( read_rows(&b"bar"[..]).flatten().collect::>(), - vec![RowInput { - label: String::from("bar"), - entries: vec![] + vec![Row { + label: "bar".to_owned(), + entries: HashMap::new(), }] ); assert_eq!( read_rows(&b"foo\nbar\n"[..]).flatten().collect::>(), vec![ - RowInput { - label: String::from("foo"), - entries: vec![] + Row { + label: "foo".to_owned(), + entries: HashMap::new(), }, - RowInput { - label: String::from("bar"), - entries: vec![] + Row { + label: "bar".to_owned(), + entries: HashMap::new(), } ] ); assert_eq!( read_rows(&b"foo\n bar\n"[..]).flatten().collect::>(), - vec![RowInput { - label: String::from("foo"), - entries: vec![Entry::from("bar")] + vec![Row { + label: "foo".to_owned(), + entries: HashMap::from([("bar".to_owned(), vec![None])]), }] ); assert_eq!( read_rows(&b"foo\n bar\n baz\n"[..]) .flatten() .collect::>(), - vec![RowInput { - label: String::from("foo"), - entries: vec![Entry::from("bar"), Entry::from("baz")] + vec![Row { + label: "foo".to_owned(), + entries: HashMap::from([ + ("bar".to_owned(), vec![None]), + ("baz".to_owned(), vec![None]) + ]), }] ); assert_eq!( @@ -340,13 +353,13 @@ mod tests { .flatten() .collect::>(), vec![ - RowInput { - label: String::from("foo"), - entries: vec![] + Row { + label: "foo".to_owned(), + entries: HashMap::new(), }, - RowInput { - label: String::from("bar"), - entries: vec![] + Row { + label: "bar".to_owned(), + entries: HashMap::new(), } ] ); @@ -355,13 +368,13 @@ mod tests { .flatten() .collect::>(), vec![ - RowInput { - label: String::from("foo"), - entries: vec![] + Row { + label: "foo".to_owned(), + entries: HashMap::new(), }, - RowInput { - label: String::from("bar"), - entries: vec![] + Row { + label: "bar".to_owned(), + entries: HashMap::new(), } ] ); @@ -369,9 +382,9 @@ mod tests { read_rows(&b"foo \n bar \n"[..]) .flatten() .collect::>(), - vec![RowInput { - label: String::from("foo"), - entries: vec![Entry::from("bar")] + vec![Row { + label: "foo".to_owned(), + entries: HashMap::from([("bar".to_owned(), vec![None])]), }] ); @@ -425,9 +438,9 @@ mod tests { assert_eq!( render_cell( "foo", - &RowInput { - label: String::from("nope"), - entries: vec![] + &mut Row { + label: "nope".to_owned(), + entries: HashMap::new(), } ), HTML::from("") @@ -435,9 +448,9 @@ mod tests { assert_eq!( render_cell( "foo", - &RowInput { - label: String::from("nope"), - entries: vec![Entry::from("bar")] + &mut Row { + label: "nope".to_owned(), + entries: HashMap::from([("bar".to_owned(), vec![None])]), } ), HTML::from("") @@ -445,9 +458,9 @@ mod tests { assert_eq!( render_cell( "foo", - &RowInput { - label: String::from("nope"), - entries: vec![Entry::from("foo")] + &mut Row { + label: "nope".to_owned(), + entries: HashMap::from([("foo".to_owned(), vec![None])]), } ), HTML::from("") @@ -455,9 +468,9 @@ mod tests { assert_eq!( render_cell( "foo", - &RowInput { - label: String::from("nope"), - entries: vec![Entry::from("foo"), Entry::from("foo")] + &mut Row { + label: "nope".to_owned(), + entries: HashMap::from([("foo".to_owned(), vec![None, None])]), } ), HTML::from("2") @@ -465,9 +478,9 @@ mod tests { assert_eq!( render_cell( "foo", - &RowInput { - label: String::from("nope"), - entries: vec![Entry::from("foo: 5"), Entry::from("foo: 10")] + &mut Row { + label: "nope".to_owned(), + entries: HashMap::from([("foo".to_owned(), vec![Some("5".to_owned()), Some("10".to_owned())])]), } ), HTML::from("5 10") @@ -475,9 +488,9 @@ mod tests { assert_eq!( render_cell( "foo", - &RowInput { - label: String::from("nope"), - entries: vec![Entry::from("foo: 5"), Entry::from("foo")] + &mut Row { + label: "nope".to_owned(), + entries: HashMap::from([("foo".to_owned(), vec![Some("5".to_owned()), None])]), } ), HTML::from("5 ✓") @@ -485,9 +498,9 @@ mod tests { assert_eq!( render_cell( "heart", - &RowInput { - label: String::from("nope"), - entries: vec![Entry::from("heart: <3")] + &mut Row { + label: "nope".to_owned(), + entries: HashMap::from([("heart".to_owned(), vec![Some("<3".to_owned())])]), } ), HTML::from("<3") @@ -495,12 +508,26 @@ mod tests { assert_eq!( render_cell( "foo", - &RowInput { - label: String::from("bob's"), - entries: vec![Entry::from("foo")] + &mut Row { + label: "bob's".to_owned(), + entries: HashMap::from([("foo".to_owned(), vec![None])]), } ), HTML::from("") ); + let mut r = Row { + label: "nope".to_owned(), + entries: HashMap::from([ + ("foo".to_owned(), vec![None]), + ("baz".to_owned(), vec![None]), + ]), + }; + assert_eq!(r.entries.len(), 2); + render_cell("foo", &mut r); + assert_eq!(r.entries.len(), 1); + render_cell("bar", &mut r); + assert_eq!(r.entries.len(), 1); + render_cell("baz", &mut r); + assert_eq!(r.entries.len(), 0); } }