X-Git-Url: http://git.scottworley.com/tablify/blobdiff_plain/54b1f74ff185bceca625df43ecfd0148d181b34c..8bf0d5b1daaf4841b1c593630d3c862e72985dda:/src/lib.rs diff --git a/src/lib.rs b/src/lib.rs index e636bb2..7292f02 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -38,37 +38,74 @@ const FOOTER: &str = " "; +#[derive(PartialEq, Eq, Debug)] +pub struct HTML(String); +impl HTML { + fn escape(value: &str) -> HTML { + let mut escaped: String = String::new(); + for c in value.chars() { + match c { + '>' => escaped.push_str(">"), + '<' => escaped.push_str("<"), + '\'' => escaped.push_str("'"), + '"' => escaped.push_str("""), + '&' => escaped.push_str("&"), + ok_c => escaped.push(ok_c), + } + } + HTML(escaped) + } +} +impl From<&str> for HTML { + fn from(value: &str) -> HTML { + HTML(String::from(value)) + } +} +impl FromIterator for HTML { + fn from_iter(iter: T) -> HTML + where + T: IntoIterator, + { + HTML(iter.into_iter().map(|html| html.0).collect::()) + } +} +impl std::fmt::Display for HTML { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.0) + } +} + #[derive(Debug, PartialEq, Eq, Hash)] -struct Entry { - col: String, - instance: Option, +struct Entry<'a> { + col: &'a str, + instance: Option<&'a str>, } -impl From<&str> for Entry { - fn from(value: &str) -> Entry { +impl<'a> From<&'a str> for Entry<'a> { + fn from(value: &'a str) -> Entry<'a> { match value.split_once(':') { None => Entry { - col: String::from(value), + col: value, instance: None, }, Some((col, instance)) => Entry { - col: String::from(col.trim()), - instance: Some(String::from(instance.trim())), + col: col.trim(), + instance: Some(instance.trim()), }, } } } #[derive(Debug, PartialEq, Eq)] -struct RowInput { - label: String, - entries: Vec, +struct RowInput<'a> { + label: &'a str, + entries: Vec>, } -struct Reader>> { +struct Reader<'a, Input: Iterator>> { input: std::iter::Enumerate, - row: Option, + row: Option>, } -impl>> Reader { +impl<'a, Input: Iterator>> Reader<'a, Input> { fn new(input: Input) -> Self { Self { input: input.enumerate(), @@ -76,21 +113,17 @@ impl>> Reader { } } } -impl>> Iterator for Reader { - type Item = Result; +impl<'a, Input: Iterator>> Iterator for Reader<'a, Input> { + type Item = Result, std::io::Error>; 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() => { + Some((_, Ok(line))) if line.trim_end().is_empty() && self.row.is_some() => { return Ok(std::mem::take(&mut self.row)).transpose() } - Some((_, Ok(line))) if line.is_empty() => {} + Some((_, Ok(line))) if line.trim_end().is_empty() => {} Some((n, Ok(line))) if line.starts_with(' ') => match &mut self.row { None => { return Some(Err(std::io::Error::other(format!( @@ -98,12 +131,14 @@ impl>> Iterator for Reader n + 1 )))) } - Some(ref mut row) => row.entries.push(Entry::from(line.trim())), + // TODO: Don't leak + Some(ref mut row) => row.entries.push(Entry::from(line.leak().trim())), }, Some((_, Ok(line))) => { let prev = std::mem::take(&mut self.row); self.row = Some(RowInput { - label: line, + // TODO: Don't leak + label: line.leak().trim_end(), entries: vec![], }); if prev.is_some() { @@ -115,7 +150,9 @@ impl>> Iterator for Reader } } -fn read_rows(input: impl std::io::Read) -> impl Iterator> { +fn read_rows( + input: impl std::io::Read, +) -> impl Iterator, std::io::Error>> { Reader::new(std::io::BufReader::new(input).lines()) } @@ -130,7 +167,7 @@ fn column_counts(rows: &[RowInput]) -> Vec<(usize, String)> { .into_iter() }) .fold(HashMap::new(), |mut cs, col| { - cs.entry(String::from(col)) + cs.entry(String::from(*col)) .and_modify(|n| *n += 1) .or_insert(1); cs @@ -148,54 +185,62 @@ fn column_order(rows: &[RowInput]) -> Vec { .collect() } -fn render_instance(entry: &Entry) -> String { +fn render_instance(entry: &Entry) -> HTML { match &entry.instance { - None => String::from("✓"), - Some(instance) => String::from(instance), + None => HTML::from("✓"), + Some(instance) => HTML::escape(instance.as_ref()), } } -fn render_cell(col: &str, row: &RowInput) -> String { - // TODO: Escape HTML special characters - let row_label = &row.label; +fn render_cell(col: &str, row: &RowInput) -> 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 = if entries.is_empty() { "" } else { "yes" }; + 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) { - String::new() + HTML::from("") } else if all_empty { - format!("{}", entries.len()) + HTML(format!("{}", entries.len())) } else { - entries - .iter() - .map(|i| render_instance(i)) - .collect::>() - .join(" ") + HTML( + entries + .iter() + .map(|i| render_instance(i)) + .map(|html| html.0) // Waiting for slice_concat_trait to stabilize + .collect::>() + .join(" "), + ) }; - format!("{contents}") + HTML(format!("{contents}")) } -fn render_row(columns: &[String], row: &RowInput) -> String { +fn render_row(columns: &[String], row: &RowInput) -> HTML { // This is O(n^2) & doesn't need to be - // TODO: Escape HTML special characters - let row_label = &row.label; - format!( + let row_label = HTML::escape(row.label.as_ref()); + HTML(format!( "{row_label}{}\n", &columns .iter() .map(|col| render_cell(col, row)) - .collect::() - ) + .collect::() + )) } -fn render_column_headers(columns: &[String]) -> String { - // TODO: Escape HTML special characters - String::from("") - + &columns.iter().fold(String::new(), |mut acc, c| { - write!(&mut acc, "
{c}
").unwrap(); - acc - }) - + "\n" +fn render_column_headers(columns: &[String]) -> HTML { + HTML( + String::from("") + + &columns.iter().fold(String::new(), |mut acc, col| { + let col_header = HTML::escape(col.as_ref()); + write!( + &mut acc, + "
{col_header}
" + ) + .unwrap(); + acc + }) + + "\n", + ) } /// # Errors @@ -204,16 +249,16 @@ fn render_column_headers(columns: &[String]) -> String { /// * 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(input: impl std::io::Read) -> Result { let rows = read_rows(input).collect::, _>>()?; let columns = column_order(&rows); - Ok(String::from(HEADER) - + &render_column_headers(&columns) - + &rows - .into_iter() + Ok(HTML(format!( + "{HEADER}{}{}{FOOTER}", + render_column_headers(&columns), + rows.into_iter() .map(|r| render_row(&columns, &r)) - .collect::() - + FOOTER) + .collect::() + ))) } #[cfg(test)] @@ -225,22 +270,22 @@ mod tests { assert_eq!( Entry::from("foo"), Entry { - col: String::from("foo"), + col: "foo", instance: None } ); assert_eq!( Entry::from("foo:bar"), Entry { - col: String::from("foo"), - instance: Some(String::from("bar")) + col: "foo", + instance: Some("bar") } ); assert_eq!( Entry::from("foo: bar"), Entry { - col: String::from("foo"), - instance: Some(String::from("bar")) + col: "foo", + instance: Some("bar") } ); } @@ -250,14 +295,14 @@ mod tests { assert_eq!( read_rows(&b"foo"[..]).flatten().collect::>(), vec![RowInput { - label: String::from("foo"), + label: "foo", entries: vec![] }] ); assert_eq!( read_rows(&b"bar"[..]).flatten().collect::>(), vec![RowInput { - label: String::from("bar"), + label: "bar", entries: vec![] }] ); @@ -265,11 +310,11 @@ mod tests { read_rows(&b"foo\nbar\n"[..]).flatten().collect::>(), vec![ RowInput { - label: String::from("foo"), + label: "foo", entries: vec![] }, RowInput { - label: String::from("bar"), + label: "bar", entries: vec![] } ] @@ -277,7 +322,7 @@ mod tests { assert_eq!( read_rows(&b"foo\n bar\n"[..]).flatten().collect::>(), vec![RowInput { - label: String::from("foo"), + label: "foo", entries: vec![Entry::from("bar")] }] ); @@ -286,7 +331,7 @@ mod tests { .flatten() .collect::>(), vec![RowInput { - label: String::from("foo"), + label: "foo", entries: vec![Entry::from("bar"), Entry::from("baz")] }] ); @@ -296,11 +341,11 @@ mod tests { .collect::>(), vec![ RowInput { - label: String::from("foo"), + label: "foo", entries: vec![] }, RowInput { - label: String::from("bar"), + label: "bar", entries: vec![] } ] @@ -311,11 +356,11 @@ mod tests { .collect::>(), vec![ RowInput { - label: String::from("foo"), + label: "foo", entries: vec![] }, RowInput { - label: String::from("bar"), + label: "bar", entries: vec![] } ] @@ -325,7 +370,7 @@ mod tests { .flatten() .collect::>(), vec![RowInput { - label: String::from("foo"), + label: "foo", entries: vec![Entry::from("bar")] }] ); @@ -381,61 +426,81 @@ mod tests { render_cell( "foo", &RowInput { - label: String::from("nope"), + label: "nope", entries: vec![] } ), - String::from("") + HTML::from("") ); assert_eq!( render_cell( "foo", &RowInput { - label: String::from("nope"), + label: "nope", entries: vec![Entry::from("bar")] } ), - String::from("") + HTML::from("") ); assert_eq!( render_cell( "foo", &RowInput { - label: String::from("nope"), + label: "nope", entries: vec![Entry::from("foo")] } ), - String::from("") + HTML::from("") ); assert_eq!( render_cell( "foo", &RowInput { - label: String::from("nope"), + label: "nope", entries: vec![Entry::from("foo"), Entry::from("foo")] } ), - String::from("2") + HTML::from("2") ); assert_eq!( render_cell( "foo", &RowInput { - label: String::from("nope"), + label: "nope", entries: vec![Entry::from("foo: 5"), Entry::from("foo: 10")] } ), - String::from("5 10") + HTML::from("5 10") ); assert_eq!( render_cell( "foo", &RowInput { - label: String::from("nope"), + label: "nope", entries: vec![Entry::from("foo: 5"), Entry::from("foo")] } ), - String::from("5 ✓") + HTML::from("5 ✓") + ); + assert_eq!( + render_cell( + "heart", + &RowInput { + label: "nope", + entries: vec![Entry::from("heart: <3")] + } + ), + HTML::from("<3") + ); + assert_eq!( + render_cell( + "foo", + &RowInput { + label: "bob's", + entries: vec![Entry::from("foo")] + } + ), + HTML::from("") ); } }