Add support for formatting lists

src/html/mod.rs

@@ -30,39 +30,54 @@ pub fn escape_html<S: ?Sized + AsRef<str>>(s: &S) -> Cow<'_, str> {
   encode_text_minimal(s)
 }
 
-#[derive(Clone, Debug)]
+fn count_digits(n: u16) -> u8 {
+  f32::log10(n.into()).floor() as u8 + 1
+}
+
+#[derive(Clone, Debug, Default)]
+enum ListState {
+  #[default]
+  None,
+  Unordered,
+  Ordered {
+    counter: u16,
+    digits: u8,
+  },
+}
+
+#[derive(Clone, Debug, Default)]
 struct FormatState {
   style: Style,
   padding: String,
+  list_state: ListState,
 }
 
 fn format_tree(
   tree: Rc<Node>,
-  state: FormatState,
+  state: &mut FormatState,
   text: &mut Text<'static>,
   mut previous_sibling_is_block: bool,
 ) -> bool {
   use markup5ever_rcdom::NodeData::*;
-  let state = match &tree.data {
+  let mut state = match &tree.data {
-    Document | Doctype { .. } | Comment { .. } | ProcessingInstruction { .. } => state,
+    Document | Doctype { .. } | Comment { .. } | ProcessingInstruction { .. } => state.to_owned(),
     Text { contents } => {
       let s: String = contents.clone().into_inner().into();
       let s = s.replace('\n', ""); // Lines are insignificant in HTML
       if previous_sibling_is_block && !s.is_empty() {
         text.lines.push(Line {
-          spans: vec![Span {
+          spans: vec![Span::styled(state.padding.to_owned(), state.style)],
-            content: Cow::Owned(state.padding.to_owned()),
-            style: state.style,
-          }],
           alignment: None,
         });
         previous_sibling_is_block = false;
       }
-      text.lines.last_mut().unwrap().spans.push(Span {
+      text
-        content: Cow::Owned(s.to_owned()),
+        .lines
-        style: state.style,
+        .last_mut()
-      });
+        .unwrap()
-      state
+        .spans
+        .push(Span::styled(s, state.style));
+      state.to_owned()
     },
     Element {
       name: QualName {
@@ -75,43 +90,116 @@ fn format_tree(
     } => match name.as_ref() {
       "br" => {
         text.lines.push(Line::raw(state.padding.to_owned()));
-        state
+        state.to_owned()
       },
       "p" => {
         previous_sibling_is_block = true;
-        state
+        state.to_owned()
       },
       "blockquote" => {
         previous_sibling_is_block = true;
         FormatState {
-          padding: state.padding + "> ",
+          padding: state.padding.to_owned() + "> ",
-          ..state
+          ..state.to_owned()
+        }
+      },
+      "ul" => {
+        previous_sibling_is_block = true;
+        FormatState {
+          list_state: ListState::Unordered,
+          ..state.to_owned()
+        }
+      },
+      "ol" => {
+        previous_sibling_is_block = true;
+        // FIXME: <li> are not guaranteed to be direct children, are they?
+        let items_count: u16 = tree
+          .children
+          .borrow()
+          .iter()
+          .map(|child| match &child.data {
+            Element {
+              name:
+                QualName {
+                  ns: ns!(html),
+                  local,
+                  ..
+                },
+              ..
+            } if local.as_ref() == "li" => 1,
+            _ => 0,
+          })
+          .sum();
+        FormatState {
+          list_state: ListState::Ordered {
+            counter: 0,
+            digits: count_digits(items_count),
+          },
+          ..state.to_owned()
+        }
+      },
+      "li" => {
+        previous_sibling_is_block = false;
+        match state.list_state {
+          ListState::None => state.to_owned(),
+          ListState::Unordered => {
+            let mut line = Line::default();
+            line
+              .spans
+              .push(Span::styled(state.padding.to_owned(), state.style));
+            line.spans.push(Span::styled("* ", state.style));
+            text.lines.push(line);
+            FormatState {
+              padding: state.padding.to_owned() + "  ",
+              ..state.to_owned()
+            }
+          },
+          ListState::Ordered {
+            ref mut counter,
+            digits,
+          } => {
+            let mut line = Line::default();
+            line
+              .spans
+              .push(Span::styled(state.padding.to_owned(), state.style));
+            *counter += 1;
+            line
+              .spans
+              .push(Span::styled(format!("{}. ", counter), state.style));
+            if count_digits(*counter) != digits {
+              line.spans.push(Span::styled(
+                " ".repeat((digits - count_digits(*counter)).into()),
+                state.style,
+              ));
+            }
+            text.lines.push(line);
+            FormatState {
+              padding: state.padding.to_owned() + "   " + &" ".repeat(digits.into()),
+              ..state.to_owned()
+            }
+          },
         }
       },
       "em" | "i" => FormatState {
         style: state.style.italic(),
-        ..state
+        ..state.to_owned()
       },
       "strong" | "b" => FormatState {
         style: state.style.bold(),
-        ..state
+        ..state.to_owned()
       },
       "u" => FormatState {
         style: state.style.underlined(),
-        ..state
+        ..state.to_owned()
       },
-      _ => state,
+      _ => state.to_owned(),
     },
-    Element { .. } => state, // Element not in the HTML namespace
+    Element { .. } => state.to_owned(), // Element not in the HTML namespace
   };
 
   for subtree in tree.children.borrow().iter() {
-    previous_sibling_is_block = format_tree(
+    previous_sibling_is_block =
-      subtree.clone(),
+      format_tree(subtree.clone(), &mut state, text, previous_sibling_is_block);
-      state.clone(),
-      text,
-      previous_sibling_is_block,
-    );
   }
 
   match &tree.data {
@@ -146,11 +234,11 @@ pub fn format_html(s: &str) -> Text<'static> {
   )
   .one(s)
   .document;
-  let state = FormatState {
+  let mut state = FormatState {
-    style: Style::default(),
     padding: "    ".to_owned(),
+    ..Default::default()
   };
   let mut text = Text::raw("");
-  format_tree(tree, state, &mut text, false);
+  format_tree(tree, &mut state, &mut text, false);
   text
 }