Move the trim_end() down

[tablify] / src / lib.rs

diff --git a/src/lib.rs b/src/lib.rs
index 370eb5ddd553a80f2cb4ce75c24703bf285e7b91..7292f0237d6765abed9e3d1b8d30143744aa3263 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -76,36 +76,36 @@ impl std::fmt::Display for HTML {
 }
 
 #[derive(Debug, PartialEq, Eq, Hash)]
 }
 
 #[derive(Debug, PartialEq, Eq, Hash)]

-struct Entry {
-    col: String,
-    instance: Option<String>,
+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 {
         match value.split_once(':') {
             None => Entry {

-                col: String::from(value),
+                col: value,

                 instance: None,
             },
             Some((col, instance)) => Entry {
                 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)]
             },
         }
     }
 }
 
 #[derive(Debug, PartialEq, Eq)]

-struct RowInput {
-    label: String,
-    entries: Vec<Entry>,
+struct RowInput<'a> {
+    label: &'a str,
+    entries: Vec<Entry<'a>>,

 }
 
 }
 

-struct Reader<Input: Iterator<Item = Result<String, std::io::Error>>> {
+struct Reader<'a, Input: Iterator<Item = Result<String, std::io::Error>>> {

     input: std::iter::Enumerate<Input>,
     input: std::iter::Enumerate<Input>,

-    row: Option<RowInput>,
+    row: Option<RowInput<'a>>,

 }
 }

-impl<Input: Iterator<Item = Result<String, std::io::Error>>> Reader<Input> {
+impl<'a, Input: Iterator<Item = Result<String, std::io::Error>>> Reader<'a, Input> {

     fn new(input: Input) -> Self {
         Self {
             input: input.enumerate(),
     fn new(input: Input) -> Self {
         Self {
             input: input.enumerate(),


@@ -113,21 +113,17 @@ impl<Input: Iterator<Item = Result<String, std::io::Error>>> Reader<Input> {
         }
     }
 }
         }
     }
 }

-impl<Input: Iterator<Item = Result<String, std::io::Error>>> Iterator for Reader<Input> {
-    type Item = Result<RowInput, std::io::Error>;
+impl<'a, Input: Iterator<Item = Result<String, std::io::Error>>> Iterator for Reader<'a, Input> {
+    type Item = Result<RowInput<'a>, std::io::Error>;

     fn next(&mut self) -> Option<Self::Item> {
         loop {
     fn next(&mut self) -> Option<Self::Item> {
         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)),
                 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()
                 }
                     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!(
                 Some((n, Ok(line))) if line.starts_with(' ') => match &mut self.row {
                     None => {
                         return Some(Err(std::io::Error::other(format!(


@@ -135,12 +131,14 @@ impl<Input: Iterator<Item = Result<String, std::io::Error>>> Iterator for Reader
                             n + 1
                         ))))
                     }
                             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 {
                 },
                 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() {
                         entries: vec![],
                     });
                     if prev.is_some() {


@@ -152,7 +150,9 @@ impl<Input: Iterator<Item = Result<String, std::io::Error>>> Iterator for Reader
     }
 }
 
     }
 }
 

-fn read_rows(input: impl std::io::Read) -> impl Iterator<Item = Result<RowInput, std::io::Error>> {
+fn read_rows(
+    input: impl std::io::Read,
+) -> impl Iterator<Item = Result<RowInput<'static>, std::io::Error>> {

     Reader::new(std::io::BufReader::new(input).lines())
 }
 
     Reader::new(std::io::BufReader::new(input).lines())
 }
 


@@ -167,7 +167,7 @@ fn column_counts(rows: &[RowInput]) -> Vec<(usize, String)> {
                 .into_iter()
         })
         .fold(HashMap::new(), |mut cs, col| {
                 .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
                 .and_modify(|n| *n += 1)
                 .or_insert(1);
             cs


@@ -270,22 +270,22 @@ mod tests {
         assert_eq!(
             Entry::from("foo"),
             Entry {
         assert_eq!(
             Entry::from("foo"),
             Entry {

-                col: String::from("foo"),
+                col: "foo",

                 instance: None
             }
         );
         assert_eq!(
             Entry::from("foo:bar"),
             Entry {
                 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 {
             }
         );
         assert_eq!(
             Entry::from("foo: bar"),
             Entry {

-                col: String::from("foo"),
-                instance: Some(String::from("bar"))
+                col: "foo",
+                instance: Some("bar")

             }
         );
     }
             }
         );
     }


@@ -295,14 +295,14 @@ mod tests {
         assert_eq!(
             read_rows(&b"foo"[..]).flatten().collect::<Vec<_>>(),
             vec![RowInput {
         assert_eq!(
             read_rows(&b"foo"[..]).flatten().collect::<Vec<_>>(),
             vec![RowInput {

-                label: String::from("foo"),
+                label: "foo",

                 entries: vec![]
             }]
         );
         assert_eq!(
             read_rows(&b"bar"[..]).flatten().collect::<Vec<_>>(),
             vec![RowInput {
                 entries: vec![]
             }]
         );
         assert_eq!(
             read_rows(&b"bar"[..]).flatten().collect::<Vec<_>>(),
             vec![RowInput {

-                label: String::from("bar"),
+                label: "bar",

                 entries: vec![]
             }]
         );
                 entries: vec![]
             }]
         );


@@ -310,11 +310,11 @@ mod tests {
             read_rows(&b"foo\nbar\n"[..]).flatten().collect::<Vec<_>>(),
             vec![
                 RowInput {
             read_rows(&b"foo\nbar\n"[..]).flatten().collect::<Vec<_>>(),
             vec![
                 RowInput {

-                    label: String::from("foo"),
+                    label: "foo",

                     entries: vec![]
                 },
                 RowInput {
                     entries: vec![]
                 },
                 RowInput {

-                    label: String::from("bar"),
+                    label: "bar",

                     entries: vec![]
                 }
             ]
                     entries: vec![]
                 }
             ]


@@ -322,7 +322,7 @@ mod tests {
         assert_eq!(
             read_rows(&b"foo\n bar\n"[..]).flatten().collect::<Vec<_>>(),
             vec![RowInput {
         assert_eq!(
             read_rows(&b"foo\n bar\n"[..]).flatten().collect::<Vec<_>>(),
             vec![RowInput {

-                label: String::from("foo"),
+                label: "foo",

                 entries: vec![Entry::from("bar")]
             }]
         );
                 entries: vec![Entry::from("bar")]
             }]
         );


@@ -331,7 +331,7 @@ mod tests {
                 .flatten()
                 .collect::<Vec<_>>(),
             vec![RowInput {
                 .flatten()
                 .collect::<Vec<_>>(),
             vec![RowInput {

-                label: String::from("foo"),
+                label: "foo",

                 entries: vec![Entry::from("bar"), Entry::from("baz")]
             }]
         );
                 entries: vec![Entry::from("bar"), Entry::from("baz")]
             }]
         );


@@ -341,11 +341,11 @@ mod tests {
                 .collect::<Vec<_>>(),
             vec![
                 RowInput {
                 .collect::<Vec<_>>(),
             vec![
                 RowInput {

-                    label: String::from("foo"),
+                    label: "foo",

                     entries: vec![]
                 },
                 RowInput {
                     entries: vec![]
                 },
                 RowInput {

-                    label: String::from("bar"),
+                    label: "bar",

                     entries: vec![]
                 }
             ]
                     entries: vec![]
                 }
             ]


@@ -356,11 +356,11 @@ mod tests {
                 .collect::<Vec<_>>(),
             vec![
                 RowInput {
                 .collect::<Vec<_>>(),
             vec![
                 RowInput {

-                    label: String::from("foo"),
+                    label: "foo",

                     entries: vec![]
                 },
                 RowInput {
                     entries: vec![]
                 },
                 RowInput {

-                    label: String::from("bar"),
+                    label: "bar",

                     entries: vec![]
                 }
             ]
                     entries: vec![]
                 }
             ]


@@ -370,7 +370,7 @@ mod tests {
                 .flatten()
                 .collect::<Vec<_>>(),
             vec![RowInput {
                 .flatten()
                 .collect::<Vec<_>>(),
             vec![RowInput {

-                label: String::from("foo"),
+                label: "foo",

                 entries: vec![Entry::from("bar")]
             }]
         );
                 entries: vec![Entry::from("bar")]
             }]
         );


@@ -426,7 +426,7 @@ mod tests {
             render_cell(
                 "foo",
                 &RowInput {
             render_cell(
                 "foo",
                 &RowInput {

-                    label: String::from("nope"),
+                    label: "nope",

                     entries: vec![]
                 }
             ),
                     entries: vec![]
                 }
             ),


@@ -436,7 +436,7 @@ mod tests {
             render_cell(
                 "foo",
                 &RowInput {
             render_cell(
                 "foo",
                 &RowInput {

-                    label: String::from("nope"),
+                    label: "nope",

                     entries: vec![Entry::from("bar")]
                 }
             ),
                     entries: vec![Entry::from("bar")]
                 }
             ),


@@ -446,7 +446,7 @@ mod tests {
             render_cell(
                 "foo",
                 &RowInput {
             render_cell(
                 "foo",
                 &RowInput {

-                    label: String::from("nope"),
+                    label: "nope",

                     entries: vec![Entry::from("foo")]
                 }
             ),
                     entries: vec![Entry::from("foo")]
                 }
             ),


@@ -456,7 +456,7 @@ mod tests {
             render_cell(
                 "foo",
                 &RowInput {
             render_cell(
                 "foo",
                 &RowInput {

-                    label: String::from("nope"),
+                    label: "nope",

                     entries: vec![Entry::from("foo"), Entry::from("foo")]
                 }
             ),
                     entries: vec![Entry::from("foo"), Entry::from("foo")]
                 }
             ),


@@ -466,7 +466,7 @@ mod tests {
             render_cell(
                 "foo",
                 &RowInput {
             render_cell(
                 "foo",
                 &RowInput {

-                    label: String::from("nope"),
+                    label: "nope",

                     entries: vec![Entry::from("foo: 5"), Entry::from("foo: 10")]
                 }
             ),
                     entries: vec![Entry::from("foo: 5"), Entry::from("foo: 10")]
                 }
             ),


@@ -476,7 +476,7 @@ mod tests {
             render_cell(
                 "foo",
                 &RowInput {
             render_cell(
                 "foo",
                 &RowInput {

-                    label: String::from("nope"),
+                    label: "nope",

                     entries: vec![Entry::from("foo: 5"), Entry::from("foo")]
                 }
             ),
                     entries: vec![Entry::from("foo: 5"), Entry::from("foo")]
                 }
             ),


@@ -486,7 +486,7 @@ mod tests {
             render_cell(
                 "heart",
                 &RowInput {
             render_cell(
                 "heart",
                 &RowInput {

-                    label: String::from("nope"),
+                    label: "nope",

                     entries: vec![Entry::from("heart: <3")]
                 }
             ),
                     entries: vec![Entry::from("heart: <3")]
                 }
             ),


@@ -496,7 +496,7 @@ mod tests {
             render_cell(
                 "foo",
                 &RowInput {
             render_cell(
                 "foo",
                 &RowInput {

-                    label: String::from("bob's"),
+                    label: "bob's",

                     entries: vec![Entry::from("foo")]
                 }
             ),
                     entries: vec![Entry::from("foo")]
                 }
             ),