-#[cfg(test)]
-use std::collections::HashMap;
-#[cfg(test)]
+use std::collections::{HashMap, HashSet};
use std::io::BufRead;
-#[cfg(test)]
use std::iter::Iterator;
+const HEADER: &str = "<!DOCTYPE html>
+<html>
+<head>
+ <meta charset=\"utf-8\">
+ <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">
+ <style>
+ /* h/t https://wabain.github.io/2019/10/13/css-rotated-table-header.html */
+ th, td { white-space: nowrap; }
+ th { text-align: left; font-weight: normal; }
+ table { border-collapse: collapse }
+ tr.key > th { height: 8em; vertical-align: bottom; line-height: 1 }
+ tr.key > th > div { width: 1em; }
+ tr.key > th > div > div { width: 5em; transform-origin: bottom left; transform: translateX(1em) rotate(-65deg) }
+ td { border: thin solid gray; }
+ td.numeric { text-align: right; }
+ td.yes { border: thin solid gray; background-color: gray; }
+ td.spacer { border: none; }
+ /* h/t https://stackoverflow.com/questions/5687035/css-bolding-some-text-without-changing-its-containers-size/46452396#46452396 */
+ .highlight { text-shadow: -0.06ex 0 black, 0.06ex 0 black; }
+ img { height: 1.2em; }
+ </style>
+ <script>
+ function highlight(id) { const e = document.getElementById(id); if (e) { e.classList.add( \"highlight\"); } }
+ function clear_highlight(id) { const e = document.getElementById(id); if (e) { e.classList.remove(\"highlight\"); } }
+ function h2(a, b) { highlight(a); highlight(b); }
+ function ch2(a, b) { clear_highlight(a); clear_highlight(b); }
+ </script>
+</head>
+<body>
+ <table>
+ <tbody>";
+const FOOTER: &str = " </tbody>
+ </table>
+</body>
+</html>";
+
+#[derive(Debug, PartialEq, Eq, Hash)]
+struct Entry {
+ col: String,
+ instance: String,
+}
+impl From<&str> for Entry {
+ fn from(value: &str) -> Entry {
+ Entry {
+ col: String::from(value),
+ instance: String::from(""),
+ }
+ }
+}
+
#[derive(Debug, PartialEq, Eq)]
struct RowInput {
label: String,
- entries: Vec<String>,
+ entries: Vec<Entry>,
}
struct Reader<Input: Iterator<Item = Result<String, std::io::Error>>> {
row: Option<RowInput>,
}
impl<Input: Iterator<Item = Result<String, std::io::Error>>> Reader<Input> {
- #[cfg(test)]
fn new(input: Input) -> Self {
Self {
input: input.enumerate(),
n + 1
))))
}
- Some(ref mut row) => row.entries.push(String::from(line.trim())),
+ Some(ref mut row) => row.entries.push(Entry::from(line.trim())),
},
Some((_, Ok(line))) => {
let prev = std::mem::take(&mut self.row);
}
}
-#[cfg(test)]
fn read_rows(input: impl std::io::Read) -> impl Iterator<Item = Result<RowInput, std::io::Error>> {
Reader::new(std::io::BufReader::new(input).lines())
}
-#[cfg(test)]
-fn column_counts(rows: &[RowInput]) -> HashMap<String, usize> {
- rows.iter()
- .flat_map(|r| r.entries.iter())
- .fold(HashMap::new(), |mut counts, e| {
- counts
- .entry(String::from(e))
- .and_modify(|c| *c += 1)
+fn column_counts(rows: &[RowInput]) -> Vec<(usize, String)> {
+ let mut counts: Vec<_> = rows
+ .iter()
+ .flat_map(|r| r.entries.iter().collect::<HashSet<_>>().into_iter())
+ .fold(HashMap::new(), |mut cs, e| {
+ cs.entry(String::from(&e.col))
+ .and_modify(|n| *n += 1)
.or_insert(1);
- counts
+ cs
})
+ .into_iter()
+ .map(|(col, n)| (n, col))
+ .collect();
+ counts.sort();
+ counts
}
-pub fn tablify(_input: &impl std::io::Read) -> String {
- String::from("Hello, world!")
+/// # Errors
+///
+/// Will return `Err` if
+/// * 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<String, std::io::Error> {
+ let rows = read_rows(input).collect::<Result<Vec<_>, _>>()?;
+ let _columns = column_counts(&rows);
+ Ok(String::from(HEADER) + "Hello, world!" + FOOTER)
}
#[cfg(test)]
read_rows(&b"foo\n bar\n"[..]).flatten().collect::<Vec<_>>(),
vec![RowInput {
label: String::from("foo"),
- entries: vec![String::from("bar")]
+ entries: vec![Entry::from("bar")]
}]
);
assert_eq!(
.collect::<Vec<_>>(),
vec![RowInput {
label: String::from("foo"),
- entries: vec![String::from("bar"), String::from("baz")]
+ entries: vec![Entry::from("bar"), Entry::from("baz")]
}]
);
assert_eq!(
.collect::<Vec<_>>(),
vec![RowInput {
label: String::from("foo"),
- entries: vec![String::from("bar")]
+ entries: vec![Entry::from("bar")]
}]
);
.collect::<Result<Vec<_>, _>>()
.unwrap()
),
- HashMap::from([(String::from("bar"), 1), (String::from("baz"), 1)])
+ vec![(1, String::from("bar")), (1, String::from("baz"))]
);
assert_eq!(
column_counts(
.collect::<Result<Vec<_>, _>>()
.unwrap()
),
- HashMap::from([(String::from("bar"), 1), (String::from("baz"), 2)])
+ vec![(1, String::from("bar")), (2, String::from("baz"))]
+ );
+ assert_eq!(
+ column_counts(
+ &read_rows(&b"foo\n bar\n bar\n baz\n bar\nquux\n baz"[..])
+ .collect::<Result<Vec<_>, _>>()
+ .unwrap()
+ ),
+ vec![(1, String::from("bar")), (2, String::from("baz"))]
);
}
}
projects / tablify / blobdiff