Expand test coverage

src/syntax/content.rs

@@ -1,3 +1,5 @@
+use std::mem::discriminant;
+
 use parser::{Token, Lexeme};
 
 use crate::graph::Graph;
@@ -21,6 +23,26 @@ pub struct TokenOutput {
     pub format_tokens: Vec<Token>,
 }
 
+impl TokenOutput {
+    pub fn only(&self, kind: &Token) -> Vec<Token> {
+        let filter = |tokens: &[Token], k: &Token| -> Vec<Token> {
+            tokens
+                .iter()
+                .filter(|&t| discriminant(t) == discriminant(k))
+                .cloned()
+                .collect::<Vec<Token>>()
+        };
+
+        let filtered_tokens = filter(&self.tokens, kind);
+        let filtered_format_tokens = filter(&self.format_tokens, kind);
+
+        [filtered_tokens, filtered_format_tokens]
+            .into_iter()
+            .flatten()
+            .collect::<Vec<Token>>()
+    }
+}
+
 pub fn parse(text: &str, graph: &Graph) -> String {
     parser::read(text, graph)
 }
@@ -28,3 +50,21 @@ pub fn parse(text: &str, graph: &Graph) -> String {
 pub fn rich_parse(text: &str, graph: &Graph) -> TokenOutput {
     parser::rich_read(text, graph)
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::syntax::content::parser::token::{Bold, Oblique};
+
+    use super::*;
+
+    #[test]
+    fn only() {
+        let graph = Graph::default();
+        let output = rich_parse("*four* *bold* and _two_ italic", &graph);
+        let bold_tokens = output.only(&Token::Bold(Bold::new(true)));
+        let italic_tokens = output.only(&Token::Oblique(Oblique::new(true)));
+        println!("{bold_tokens:?}");
+        assert_eq!(bold_tokens.len(), 4);
+        assert_eq!(italic_tokens.len(), 2);
+    }
+}

src/syntax/content/parser/token.rs

@@ -1,4 +1,4 @@
-use crate::syntax::content::Parseable as _;
+use crate::syntax::content::Parseable;
 
 pub mod anchor;
 pub mod bold;

src/syntax/content/parser/token/anchor.rs

@@ -15,29 +15,6 @@ pub struct Anchor {
 }
 
 impl Anchor {
-    pub fn new(
-        text: &str,
-        destination: &str,
-        node: Option<Node>,
-        node_id: Option<String>,
-        leading: bool,
-        external: bool,
-        balanced: bool,
-    ) -> Anchor {
-        let mut anchor = Anchor {
-            text: text.to_owned(),
-            destination: Some(String::from(destination)),
-            node,
-            node_id,
-            leading,
-            external,
-            balanced,
-        };
-
-        anchor.route();
-        anchor
-    }
-
     pub fn text(&self) -> String {
         self.text.clone()
     }
@@ -287,4 +264,18 @@ mod tests {
         anchor.route(); // set_destination also called this
         assert!(anchor.destination().is_none());
     }
+
+    #[test]
+    fn set_node_id() {
+        let payload = "kxBDJ0EoDVaygxpZ8NgNdQrUIBsGimTs";
+        let mut anchor = Anchor::default();
+        anchor.set_node_id(payload);
+        assert_eq!(anchor.node_id.unwrap(), payload);
+    }
+
+    #[test]
+    fn display_no_destination() {
+        let anchor = Anchor::default();
+        assert_eq!(format!("{anchor}"), "Anchor <empty> -> <unknown>");
+    }
 }

src/syntax/content/parser/token/bold.rs

@@ -76,4 +76,10 @@ mod tests {
             "Tk:Bold [closed]"
         );
     }
+
+    #[test]
+    fn flatten() {
+        let bold = Bold::new(false);
+        assert_eq!(bold.flatten(), "");
+    }
 }

src/syntax/content/parser/token/checkbox.rs

@@ -75,4 +75,10 @@ mod tests {
             "Tk:CheckBox [empty]"
         );
     }
+
+    #[test]
+    fn flatten() {
+        let checkbox = CheckBox::new(false);
+        assert_eq!(checkbox.flatten(), "");
+    }
 }

src/syntax/content/parser/token/header.rs

@@ -300,4 +300,30 @@ mod tests {
             "Tk:Header [closed L2]"
         );
     }
+
+    #[test]
+    fn display_unknown_open_state() {
+        let header = Header {
+            open: None,
+            dom_id: None,
+            level: Level::One,
+        };
+
+        assert_eq!(format!("{header}"), "Header [unknown L1]");
+    }
+
+    #[test]
+    fn display_dom_id() {
+        let payload = "WIV0h1wCeY7Pp3FkjgIftJHX1I6YvnSc";
+        let header = Header {
+            open: None,
+            dom_id: Some(payload.to_string()),
+            level: Level::One,
+        };
+
+        assert_eq!(
+            format!("{header}"),
+            format!("Header [unknown L1 DOM ID {payload}]")
+        );
+    }
 }

src/syntax/content/parser/token/item.rs

@@ -89,4 +89,10 @@ mod tests {
             "Tk:Item [<unknown>] dRMy4"
         );
     }
+
+    #[test]
+    fn flatten() {
+        let item = Item::new("", None);
+        assert_eq!(item.flatten(), "");
+    }
 }

src/syntax/content/parser/token/list.rs

@@ -189,4 +189,23 @@ mod tests {
         let lexeme = Lexeme::new("SL6PX", "6xsNB", "oeAHa");
         List::lex(&lexeme);
     }
+
+    #[test]
+    fn ordered_list() {
+        let mut list = List::new(true);
+        list.items = vec![
+            Item::new("a", Some(0)),
+            Item::new("b", Some(0)),
+            Item::new("c", Some(0)),
+        ];
+
+        assert_eq!(
+            list.render(),
+            "\n<ol>\n\
+            <li>a</li>\n\
+            <li>b</li>\n\
+            <li>c</li>\n\
+            </ol>\n\n"
+        );
+    }
 }

src/syntax/content/parser/token/oblique.rs

@@ -79,4 +79,10 @@ mod tests {
             "Tk:Oblique [closed]"
         );
     }
+
+    #[test]
+    fn flatten() {
+        let oblique = Oblique::new(false);
+        assert_eq!(oblique.flatten(), "");
+    }
 }

src/syntax/content/parser/token/preformat.rs

@@ -99,4 +99,10 @@ mod tests {
             "Tk:PreFormat [unknown]"
         );
     }
+
+    #[test]
+    fn flatten() {
+        let preformat = PreFormat::new(false);
+        assert_eq!(preformat.flatten(), "");
+    }
 }

src/syntax/content/parser/token/strike.rs

@@ -76,4 +76,10 @@ mod tests {
             "Tk:Strike [closed]"
         );
     }
+
+    #[test]
+    fn flatten() {
+        let strike = Strike::new(false);
+        assert_eq!(strike.flatten(), "");
+    }
 }

src/syntax/content/parser/token/underline.rs

@@ -79,4 +79,10 @@ mod tests {
             "Tk:Underline [closed]"
         );
     }
+
+    #[test]
+    fn flatten() {
+        let underline = Underline::new(false);
+        assert_eq!(underline.flatten(), "");
+    }
 }