Make lexeme and token logging more concise

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

@@ -22,7 +22,7 @@ impl Parseable for Anchor {
     fn render(&self) -> String {
         let Some(ref destination) = self.destination else {
             panic!(
-                "Attempt to render anchor {self:?} without knowing its destination."
+                "Attempt to render anchor {self:#?} without knowing its destination."
             )
         };
 
@@ -40,6 +40,41 @@ impl Parseable for Anchor {
     }
 }
 
+impl std::fmt::Display for Anchor {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        use crate::dev::wrap;
+
+        let display_destination = match self.destination {
+            Some(ref destination) => { if destination.is_empty() {
+                "<empty>"
+            } else {
+                destination
+            }},
+            None => "<unknown>"
+        };
+
+        let mut tail = String::new();
+
+        if self.leading {
+            tail.push_str(" [Leading]");
+        }
+        if self.balanced {
+            tail.push_str(" [Balanced]");
+        }
+        if self.external {
+            tail.push_str(" [External]");
+        }
+
+        write!(
+            f,
+            "Anchor {:?} -> {:?}{}",
+            wrap(&self.text),
+            display_destination,
+            tail
+        )
+    }
+}
+
 impl Anchor {
     pub fn new(
         text: &str,

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

@@ -31,6 +31,13 @@ impl Parseable for Code {
     }
 }
 
+impl std::fmt::Display for Code {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let display_open_state = if self.open { "open" } else { "closed" };
+        write!(f, "Code [{display_open_state}]")
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

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

@@ -112,6 +112,27 @@ impl Parseable for Header {
     }
 }
 
+impl std::fmt::Display for Header {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let display_open_state = if let Some(open_state) = self.open {
+            if open_state { "open" } else { "closed" }
+        } else {
+            "unknown"
+        };
+
+        let display_dom_id = match self.dom_id {
+            Some(ref dom_id) => format!(" DOM ID {dom_id}"),
+            None => String::new()
+        };
+
+        write!(
+            f,
+            "Header [{} L{}{}]",
+            display_open_state, self.level, display_dom_id
+        )
+    }
+}
+
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Level {
     One,

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

@@ -18,3 +18,9 @@ impl Parseable for LineBreak {
         "\n".to_owned()
     }
 }
+
+impl std::fmt::Display for LineBreak {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "LineBreak")
+    }
+}

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

@@ -20,3 +20,9 @@ impl Parseable for Literal {
         self.text.clone()
     }
 }
+
+impl std::fmt::Display for Literal {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "Literal {}", crate::dev::wrap(&self.text))
+    }
+}

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

@@ -31,6 +31,13 @@ impl Parseable for Oblique {
     }
 }
 
+impl std::fmt::Display for Oblique {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let display_open_state = if self.open { "open" } else { "closed" };
+        write!(f, "Oblique [{display_open_state}]")
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

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

@@ -40,6 +40,16 @@ impl Parseable for Paragraph {
     }
 }
 
+impl std::fmt::Display for Paragraph {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let display_open_state = match self.open {
+            Some(open_state) => { if open_state { "open" } else { "closed" } },
+            None => "unknown"
+        };
+        write!(f, "Paragraph [{display_open_state}]")
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

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

@@ -13,6 +13,17 @@ impl PreFormat {
     }
 }
 
+impl std::fmt::Display for PreFormat {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let display_open_state = if let Some(open_state) = self.open {
+            if open_state { "open" } else { "closed" }
+        } else {
+            "unknown"
+        };
+        write!(f, "PreFormat [{display_open_state}]")
+    }
+}
+
 impl Parseable for PreFormat {
     fn probe(lexeme: &Lexeme) -> bool {
         lexeme.match_first_char('`') && (lexeme.next() == "\n" || lexeme.last())

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

@@ -34,6 +34,17 @@ impl Parseable for Span {
     }
 }
 
+impl std::fmt::Display for Span {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let display_open_state = match self.open {
+            Some(ref open_state) => {
+            if *open_state { "open" } else { "closed" }},
+                None => "unknown"
+        };
+        write!(f, "Span [{display_open_state}]")
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;