From 613611707c2177a432d669a547115f5ed508e3d7 Mon Sep 17 00:00:00 2001
From: Laith <laithbahodi@gmail.com>
Date: Sat, 21 Sep 2024 16:49:45 -0400
Subject: [PATCH 01/14] feat: resillient keywords

no more errors on EOFS

handle attr
---
 crates/org-parser/src/element/keyword.rs | 110 +++++++++++++++++++----
 crates/org-parser/src/types.rs           |   2 +-
 2 files changed, 93 insertions(+), 19 deletions(-)

diff --git a/crates/org-parser/src/element/keyword.rs b/crates/org-parser/src/element/keyword.rs
index 634a16d..f8ca070 100644
--- a/crates/org-parser/src/element/keyword.rs
+++ b/crates/org-parser/src/element/keyword.rs
@@ -2,7 +2,7 @@ use crate::constants::{DOLLAR, HYPHEN, NEWLINE, UNDERSCORE};
 use crate::node_pool::NodeID;
 use crate::parse::parse_element;
 use crate::types::{process_attrs, Cursor, Expr, MatchError, ParseOpts, Parseable, Parser, Result};
-use crate::utils::Match;
+use crate::utils::{bytes_to_str, Match};
 
 use super::Paragraph;
 
@@ -83,6 +83,11 @@ impl<'a> Parseable<'a> for Keyword<'a> {
             ));
         }
         let key_word = cursor.fn_until(|chr: u8| chr == b':' || chr.is_ascii_whitespace())?;
+        // TODO warning
+        // not valid: #+: ...
+        if key_word.len() == 0 {
+            Err(MatchError::InvalidLogic)?
+        }
         cursor.index = key_word.end;
         cursor.word(":")?;
 
@@ -98,9 +103,13 @@ impl<'a> Parseable<'a> for Keyword<'a> {
                 }
             }
             "name" => {
-                let val = cursor.fn_until(|chr: u8| chr == b'\n')?;
-                cursor.index = val.end;
+                let prev = cursor.index;
+                cursor.adv_till_byte(NEWLINE);
+                // not mentioned in the spec, but org-element trims
+                let val = bytes_to_str(&cursor.byte_arr[prev..cursor.index].trim_ascii());
+
                 cursor.next();
+                let end_index = cursor.index;
 
                 let child_id = loop {
                     if let Ok(child_id) = parse_element(parser, cursor, parent, parse_opts) {
@@ -109,15 +118,14 @@ impl<'a> Parseable<'a> for Keyword<'a> {
                             // skip affiliated objects
                             cursor.index = node.end;
                         } else {
-                            parser.pool[child_id].id_target =
-                                Some(parser.generate_target(val.obj.trim()));
+                            parser.pool[child_id].id_target = Some(parser.generate_target(val));
                             break Some(child_id);
                         }
                     } else {
                         break None;
                     };
                 };
-                let ret_id = parser.alloc(Affiliated::Name(child_id), start, val.end + 1, parent);
+                let ret_id = parser.alloc(Affiliated::Name(child_id), start, end_index, parent);
 
                 return Ok(ret_id);
             }
@@ -155,18 +163,19 @@ impl<'a> Parseable<'a> for Keyword<'a> {
             _ => {}
         }
 
-        let val = cursor.fn_until(|chr: u8| chr == b'\n')?;
-        // TODO: use an fn_until_inclusive to not have to add 1 to the end
-        // (we want to eat the ending nl too)
-        parser.keywords.insert(key_word.obj, val.obj.trim());
+        let prev = cursor.index;
+        cursor.adv_till_byte(NEWLINE);
+        // not mentioned in the spec, but org-element trims
+        let val = bytes_to_str(&cursor.byte_arr[prev..cursor.index].trim_ascii());
+
+        parser.keywords.insert(key_word.obj, val);
         Ok(parser.alloc(
             Keyword {
                 key: key_word.obj,
-                // not mentioned in the spec, but org-element trims
-                val: val.obj.trim(),
+                val,
             },
             start,
-            val.end + 1,
+            cursor.index + 1,
             parent,
         ))
     }
@@ -195,7 +204,7 @@ impl<'a> MacroDef<'a> {
         cursor.skip_ws();
         // A string starting with a alphabetic character followed by any number of
         // alphanumeric characters, hyphens and underscores (-_).
-        if !cursor.curr().is_ascii_alphabetic() || cursor.curr() == NEWLINE {
+        if !cursor.try_curr()?.is_ascii_alphabetic() || cursor.curr() == NEWLINE {
             return Err(MatchError::InvalidLogic);
         }
 
@@ -206,7 +215,7 @@ impl<'a> MacroDef<'a> {
 
         cursor.skip_ws();
         // macro with no body?
-        if cursor.curr() == NEWLINE {
+        if cursor.try_curr()? == NEWLINE {
             return Err(MatchError::InvalidLogic);
         }
 
@@ -215,7 +224,7 @@ impl<'a> MacroDef<'a> {
         let mut ret_vec: Vec<ArgNumOrText> = Vec::new();
         let mut num_args = 0;
         loop {
-            match cursor.curr() {
+            match cursor.try_curr()? {
                 DOLLAR => {
                     if cursor.peek(1)?.is_ascii_digit() {
                         ret_vec.push(ArgNumOrText::Text(cursor.clamp_backwards(prev_ind)));
@@ -258,7 +267,11 @@ impl<'a> MacroDef<'a> {
 mod tests {
     use std::collections::HashMap;
 
-    use crate::{element::Keyword, expr_in_pool, node_in_pool, parse_org, types::Expr};
+    use crate::{
+        element::{Affiliated, Keyword},
+        expr_in_pool, node_in_pool, parse_org,
+        types::Expr,
+    };
 
     #[test]
     fn basic_keyword() {
@@ -360,6 +373,67 @@ yeah
 "#;
 
         let parsed = parse_org(input);
-        parsed.print_tree();
+        let cap = expr_in_pool!(parsed, Affiliated).unwrap();
+
+        match cap {
+            Affiliated::Caption(Some(child), id) => {
+                let Expr::Paragraph(para) = &parsed.pool[*id].obj else {
+                    unreachable!()
+                };
+                let Expr::Bold(bold_obj) = &parsed.pool[para.0[0]].obj else {
+                    unreachable!()
+                };
+                let Expr::Plain(letters) = &parsed.pool[bold_obj.0[0]].obj else {
+                    unreachable!()
+                };
+                assert_eq!(letters, &"hi");
+
+                let Expr::Paragraph(para) = &parsed.pool[*child].obj else {
+                    unreachable!()
+                };
+
+                let Expr::Plain(letters) = &parsed.pool[para.0[0]].obj else {
+                    unreachable!()
+                };
+                assert_eq!(letters, &"yeah");
+            }
+            _ => {
+                panic!("oops")
+            }
+        }
+    }
+
+    #[test]
+    fn affiliated_name() {
+        let input = r"
+
+#+CAPTION: this is a list
+#+NAME: yes_my_list
+- yes
+
+#+name: yes_my_list
+[[yes_my_list]]
+";
+
+        let parsed = parse_org(input);
+        assert_eq!(
+            parsed.targets.get("yes_my_list").unwrap(),
+            &"yes_my_list".into()
+        );
+        assert_eq!(parsed.target_occurences.get("yes_my_list").unwrap(), &1);
+        // parsed.print_tree();
+    }
+
+    #[test]
+    fn macro_eof() {
+        let i1 = r"#+macro:";
+        let i2 = r"#+macro: name";
+        let i3 = r"#+macro: name ";
+        let i4 = r"#+macro: name thing";
+        let inps = vec![i1, i2, i3, i4];
+        inps.iter().for_each(|x| {
+            parse_org(x);
+        });
     }
 }
+
diff --git a/crates/org-parser/src/types.rs b/crates/org-parser/src/types.rs
index 00b65d0..870233c 100644
--- a/crates/org-parser/src/types.rs
+++ b/crates/org-parser/src/types.rs
@@ -64,7 +64,7 @@ pub(crate) fn process_attrs<'a>(
                 // allows for non-breaking colons:
                 // #+attr_html: :style border:2px solid black
                 loop {
-                    match cursor.curr() {
+                    match cursor.try_curr()? {
                         NEWLINE => break,
                         COLON => {
                             if cursor.peek_rev(1)?.is_ascii_whitespace() {

From 3ce78b09102f49590a9b7d639e9669c344aadbcc Mon Sep 17 00:00:00 2001
From: Laith <laithbahodi@gmail.com>
Date: Sat, 21 Sep 2024 16:53:32 -0400
Subject: [PATCH 02/14] refactor: rename is_index_valid to curr_valid

---
 crates/org-parser/src/element/drawer.rs       |  4 ++--
 crates/org-parser/src/element/item.rs         |  6 +++---
 crates/org-parser/src/element/table.rs        |  2 +-
 crates/org-parser/src/object/node_property.rs |  2 +-
 crates/org-parser/src/parse.rs                |  2 +-
 crates/org-parser/src/types.rs                | 10 +++++++---
 6 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/crates/org-parser/src/element/drawer.rs b/crates/org-parser/src/element/drawer.rs
index 23a4019..7390656 100644
--- a/crates/org-parser/src/element/drawer.rs
+++ b/crates/org-parser/src/element/drawer.rs
@@ -30,7 +30,7 @@ impl<'a> Parseable<'a> for Drawer<'a> {
         parse_opts: ParseOpts,
     ) -> Result<NodeID> {
         let start = cursor.index;
-        cursor.is_index_valid()?;
+        cursor.curr_valid()?;
         cursor.skip_ws();
         cursor.word(":")?;
 
@@ -85,8 +85,8 @@ impl<'a> Parseable<'a> for Drawer<'a> {
 pub type PropertyDrawer<'a> = HashMap<&'a str, Cow<'a, str>>;
 
 pub(crate) fn parse_property(mut cursor: Cursor) -> Result<Match<PropertyDrawer>> {
+    cursor.curr_valid()?;
     let start = cursor.index;
-    cursor.is_index_valid()?;
     cursor.skip_ws();
     cursor.word(":")?;
 
diff --git a/crates/org-parser/src/element/item.rs b/crates/org-parser/src/element/item.rs
index 35bca6a..ce1c05c 100644
--- a/crates/org-parser/src/element/item.rs
+++ b/crates/org-parser/src/element/item.rs
@@ -236,7 +236,7 @@ fn parse_counter_set(mut cursor: Cursor) -> Result<Match<&str>> {
 fn parse_tag(mut cursor: Cursor) -> Result<Match<&str>> {
     // - [@A] [X] | our tag is here :: remainder
     let start = cursor.index;
-    cursor.is_index_valid()?;
+    cursor.curr_valid()?;
     cursor.skip_ws();
 
     let end = loop {
@@ -286,12 +286,12 @@ impl From<&CheckBox> for &str {
 impl CheckBox {
     fn parse(mut cursor: Cursor) -> Result<Match<CheckBox>> {
         let start = cursor.index;
-        cursor.is_index_valid()?;
         cursor.skip_ws();
         // we're at a LBRACK in theory here
         // 012
         // [ ]
-        if cursor.curr() != LBRACK && cursor.peek(2)? != RBRACK {
+
+        if cursor.try_curr()? != LBRACK || cursor.peek(2)? != RBRACK {
             return Err(MatchError::InvalidLogic);
         }
 
diff --git a/crates/org-parser/src/element/table.rs b/crates/org-parser/src/element/table.rs
index 96e1f69..ed28afd 100644
--- a/crates/org-parser/src/element/table.rs
+++ b/crates/org-parser/src/element/table.rs
@@ -90,7 +90,7 @@ impl<'a> Parseable<'a> for TableRow {
         // TODO: doesn't play well with lists
         // should break if the indentation is not even for the next element in the list
         // but shouldn't break otherwise
-        cursor.is_index_valid()?;
+        cursor.curr_valid()?;
         cursor.skip_ws();
         cursor.word("|")?;
 
diff --git a/crates/org-parser/src/object/node_property.rs b/crates/org-parser/src/object/node_property.rs
index 9410449..0ebcd8d 100644
--- a/crates/org-parser/src/object/node_property.rs
+++ b/crates/org-parser/src/object/node_property.rs
@@ -16,7 +16,7 @@ pub(crate) fn parse_node_property<'a>(
     properties: &mut PropertyDrawer<'a>,
     // end index
 ) -> Result<usize> {
-    cursor.is_index_valid()?;
+    cursor.curr_valid()?;
     let start = cursor.index;
     cursor.skip_ws();
     cursor.word(":")?;
diff --git a/crates/org-parser/src/parse.rs b/crates/org-parser/src/parse.rs
index 8e916f3..6fcc025 100644
--- a/crates/org-parser/src/parse.rs
+++ b/crates/org-parser/src/parse.rs
@@ -26,7 +26,7 @@ pub(crate) fn parse_element<'a>(
         return Ok(*id);
     }
 
-    cursor.is_index_valid()?;
+    cursor.curr_valid()?;
     // means a newline checking thing called this, and newline breaks all
     // table rows
     if parse_opts.markup.contains(MarkupKind::Table) {
diff --git a/crates/org-parser/src/types.rs b/crates/org-parser/src/types.rs
index 870233c..bf8cd7f 100644
--- a/crates/org-parser/src/types.rs
+++ b/crates/org-parser/src/types.rs
@@ -273,7 +273,7 @@ impl<'a> Cursor<'a> {
             .ok_or(MatchError::EofError)
     }
 
-    pub fn is_index_valid(&self) -> Result<()> {
+    pub fn curr_valid(&self) -> Result<()> {
         if self.index < self.byte_arr.len() {
             Ok(())
         } else {
@@ -291,8 +291,12 @@ impl<'a> Cursor<'a> {
     }
 
     pub fn skip_ws(&mut self) {
-        while self.curr() == SPACE {
-            self.next();
+        while let Ok(curr_item) = self.try_curr() {
+            if self.curr() == SPACE {
+                self.next()
+            } else {
+                break;
+            }
         }
     }
 

From 361f818ae84578032c0e8618bde148b0cf6aec46 Mon Sep 17 00:00:00 2001
From: Laith <laithbahodi@gmail.com>
Date: Sat, 21 Sep 2024 16:58:46 -0400
Subject: [PATCH 03/14] feat: resillient hrules + leading spaces

---
 crates/org-parser/src/parse.rs | 77 ++++++++++++++++++++++++++++++----
 1 file changed, 69 insertions(+), 8 deletions(-)

diff --git a/crates/org-parser/src/parse.rs b/crates/org-parser/src/parse.rs
index 6fcc025..dca97cd 100644
--- a/crates/org-parser/src/parse.rs
+++ b/crates/org-parser/src/parse.rs
@@ -37,7 +37,7 @@ pub(crate) fn parse_element<'a>(
     let mut indented_loc = cursor.index;
     let mut new_opts = parse_opts;
     loop {
-        let byte = cursor[indented_loc];
+        let byte = *cursor.get(indented_loc).ok_or(MatchError::InvalidLogic)?;
         if byte.is_ascii_whitespace() {
             if byte == NEWLINE {
                 return Ok(parser.alloc(Expr::BlankLine, cursor.index, indented_loc + 1, parent));
@@ -106,19 +106,30 @@ pub(crate) fn parse_element<'a>(
             }
         }
         HYPHEN => {
-            {
+            let hrule_parse = |parser: &mut Parser,
+                               mut cursor: Cursor,
+                               parent: Option<NodeID>,
+                               _new_opts: ParseOpts|
+             -> Result<NodeID> {
                 // handle Hrule: at least 5 consecutive hyphens
                 let start = cursor.index;
-                while HYPHEN == cursor.curr() {
-                    cursor.next();
+                while let Ok(curr_item) = cursor.try_curr() {
+                    if HYPHEN == curr_item {
+                        cursor.next();
+                    } else {
+                        break;
+                    }
                 }
-                if NEWLINE == cursor.curr() && cursor.index - start >= 5 {
+                if NEWLINE == cursor.try_curr()? && cursor.index - start >= 5 {
                     return Ok(parser.alloc(Expr::HorizontalRule, start, cursor.index + 1, parent));
                 } else {
-                    cursor.index = start;
+                    Err(MatchError::InvalidLogic)
                 }
-            }
-            if let ret @ Ok(_) = PlainList::parse(parser, cursor, parent, new_opts) {
+            };
+
+            if let ret @ Ok(_) = hrule_parse(parser, cursor, parent, new_opts) {
+                return ret;
+            } else if let ret @ Ok(_) = PlainList::parse(parser, cursor, parent, new_opts) {
                 return ret;
             }
         }
@@ -363,3 +374,53 @@ fn parse_text<'a>(
 
     parser.alloc(cursor.clamp_backwards(start), start, cursor.index, parent)
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{expr_in_pool, parse_org};
+
+    use super::*;
+
+    #[test]
+    fn check_valid_hrule() {
+        let src = "------\n";
+        let parsed = parse_org(src);
+
+        let hrule = parsed
+            .pool
+            .iter()
+            .find_map(|x| {
+                if let Expr::HorizontalRule = &x.obj {
+                    Some(x)
+                } else {
+                    None
+                }
+            })
+            .unwrap();
+    }
+    #[test]
+    fn check_invalid_hrule() {
+        let src = "--------s\n";
+        let parsed = parse_org(src);
+
+        let hrule = parsed.pool.iter().find_map(|x| {
+            if let Expr::HorizontalRule = &x.obj {
+                Some(x)
+            } else {
+                None
+            }
+        });
+        if let Some(_) = hrule {
+            unreachable!()
+        }
+    }
+
+    #[test]
+    #[should_panic] // would like this not to panic, but indentation / leading spaces are weird right now
+    fn only_spaces() {
+        let src = "   ";
+        let parsed = parse_org(src);
+        let plain = expr_in_pool!(parsed, Plain).unwrap();
+        assert_eq!(plain, &"   " );
+    }
+}

From 257cfe8b02dcff0a5da9cec5e5f4f71854bb09b6 Mon Sep 17 00:00:00 2001
From: Laith <laithbahodi@gmail.com>
Date: Sat, 21 Sep 2024 17:00:59 -0400
Subject: [PATCH 04/14] feat: resillient latex frags

---
 crates/org-exporter/src/html.rs            | 15 ++++++---------
 crates/org-parser/src/object/latex_frag.rs | 10 +++++++++-
 2 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/crates/org-exporter/src/html.rs b/crates/org-exporter/src/html.rs
index dd5125a..32eec60 100644
--- a/crates/org-exporter/src/html.rs
+++ b/crates/org-exporter/src/html.rs
@@ -541,18 +541,15 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                 }
             }
             Expr::LatexEnv(inner) => {
-                let ret = latex_to_mathml(
-                    &format!(
-                        r"\begin{{{0}}}
+                let formatted = &format!(
+                    r"\begin{{{0}}}
 {1}
 \end{{{0}}}
 ",
-                        inner.name, inner.contents
-                    ),
-                    DisplayStyle::Block,
-                )
-                .unwrap();
-                writeln!(self, "{ret}")?;
+                    inner.name, inner.contents
+                );
+                let ret = latex_to_mathml(&formatted, DisplayStyle::Block);
+                writeln!(self, "{}", if let Ok(val) = &ret { val } else { formatted })?;
             }
             Expr::LatexFragment(inner) => match inner {
                 LatexFragment::Command { name, contents } => {
diff --git a/crates/org-parser/src/object/latex_frag.rs b/crates/org-parser/src/object/latex_frag.rs
index f17604b..d1fa142 100644
--- a/crates/org-parser/src/object/latex_frag.rs
+++ b/crates/org-parser/src/object/latex_frag.rs
@@ -152,7 +152,7 @@ impl<'a> Parseable<'a> for LatexFragment<'a> {
                         return Ok(parser.alloc(entity, start, end_name_ind, parent));
                     }
 
-                    match cursor.curr() {
+                    match cursor.try_curr()? {
                         LBRACE => {
                             cursor.next();
                             loop {
@@ -472,4 +472,12 @@ c}
         dbg!(&pool);
         pool.print_tree();
     }
+
+    #[test]
+    fn single_backslash_char_eof() {
+        let input = r"   \s";
+        let pool = parse_org(input);
+        let item = expr_in_pool!(pool, Plain).unwrap();
+        assert_eq!(item, &r"\s");
+    }
 }

From 59b25a2a8f763676144d1e83e95a397bc53fdbd3 Mon Sep 17 00:00:00 2001
From: Laith <laithbahodi@gmail.com>
Date: Sat, 21 Sep 2024 17:03:45 -0400
Subject: [PATCH 05/14] feat: resillient tables

---
 crates/org-parser/src/element/table.rs | 49 +++++++++++++++-----------
 1 file changed, 28 insertions(+), 21 deletions(-)

diff --git a/crates/org-parser/src/element/table.rs b/crates/org-parser/src/element/table.rs
index ed28afd..a547586 100644
--- a/crates/org-parser/src/element/table.rs
+++ b/crates/org-parser/src/element/table.rs
@@ -94,15 +94,22 @@ impl<'a> Parseable<'a> for TableRow {
         cursor.skip_ws();
         cursor.word("|")?;
 
+        // we deliberately avoid erroring out of the function from here
+        // in the case of "|EOF" since we need to allocate a node to tell the parent
+        // that we've successfully read past the "|"
+        // otherwise, Table will allocate in the cache with zero progress, and cause an infinite loop
+
         // implies horizontal rule
         // |-
-        if cursor.try_curr()? == HYPHEN {
-            // adv_till_byte handles eof
-            cursor.adv_till_byte(b'\n');
-            // cursor.index + 1 to start at the next | on the next line
-            return Ok(parser
-                .pool
-                .alloc(Self::Rule, start, cursor.index + 1, parent));
+        if let Ok(val) = cursor.try_curr() {
+            if val == HYPHEN {
+                // adv_till_byte handles eof
+                cursor.adv_till_byte(b'\n');
+                // cursor.index + 1 to start at the next | on the next line
+                return Ok(parser
+                    .pool
+                    .alloc(Self::Rule, start, cursor.index + 1, parent));
+            }
         }
 
         let mut children: Vec<NodeID> = Vec::new();
@@ -111,9 +118,12 @@ impl<'a> Parseable<'a> for TableRow {
             children.push(table_cell_id);
 
             cursor.index = node_item.end;
-            // REVIEW: use try_curr in case of table ending at eof?
-            if cursor.curr() == NEWLINE {
-                cursor.next();
+            if let Ok(val) = cursor.try_curr() {
+                if val == NEWLINE {
+                    cursor.next();
+                    break;
+                }
+            } else {
                 break;
             }
         }
@@ -126,7 +136,7 @@ impl<'a> Parseable<'a> for TableRow {
 
 #[cfg(test)]
 mod tests {
-    use crate::parse_org;
+    use crate::{expr_in_pool, parse_org, Expr};
 
     #[test]
     fn basic_table() {
@@ -151,8 +161,6 @@ mod tests {
     }
 
     #[test]
-    #[should_panic]
-    // we don't handle the eof case for table cells /shrug/
     fn table_eof_2() {
         let input = r"
 |one|two|
@@ -265,13 +273,12 @@ word
         pool.print_tree();
     }
 
-    // #[test]
-    // #[should_panic]
-    // fn table_no_start() {
-    //     let input = r"|";
-
-    //     let pool = parse_org(input);
+    #[test]
+    fn table_no_start() {
+        let input = r"|";
 
-    //     pool.pool.root().print_tree(&pool);
-    // }
+        let pool = parse_org(input);
+        let tab = expr_in_pool!(pool, Table).unwrap();
+        assert_eq!(tab.rows, 1);
+    }
 }

From b62f7bf9903e6d83eeba5c6f81f409e9e43d92c2 Mon Sep 17 00:00:00 2001
From: Laith <laithbahodi@gmail.com>
Date: Sat, 21 Sep 2024 17:04:19 -0400
Subject: [PATCH 06/14] feat: resillient lists

---
 crates/org-parser/src/element/item.rs | 68 ++++++++++++++++++++++-----
 1 file changed, 56 insertions(+), 12 deletions(-)

diff --git a/crates/org-parser/src/element/item.rs b/crates/org-parser/src/element/item.rs
index ce1c05c..977491e 100644
--- a/crates/org-parser/src/element/item.rs
+++ b/crates/org-parser/src/element/item.rs
@@ -61,10 +61,12 @@ impl<'a> Parseable<'a> for Item<'a> {
         // if the last element was a \n, that means we're starting on a new line
         // so we are Not on a list line.
         cursor.skip_ws();
-        if cursor.try_curr()? == NEWLINE {
-            cursor.next();
-        } else {
-            parse_opts.list_line = true;
+        if let Ok(item) = cursor.try_curr() {
+            if item == NEWLINE {
+                cursor.next()
+            } else {
+                parse_opts.list_line = true;
+            }
         }
 
         // used to restore index to the previous position in the event of two
@@ -191,16 +193,14 @@ impl BulletKind {
 // - [@4]
 fn parse_counter_set(mut cursor: Cursor) -> Result<Match<&str>> {
     let start = cursor.index;
-    cursor.is_index_valid()?;
     cursor.skip_ws();
-
     cursor.word("[@")?;
 
     let num_match = cursor.fn_while(|chr| chr.is_ascii_alphanumeric())?;
 
     cursor.index = num_match.end;
 
-    // TODO: errors on eof
+    // cursor.curr() is valid because num_match above ensures we're at a valid point
     if cursor.curr() != RBRACK {
         Err(MatchError::InvalidLogic)?;
     }
@@ -315,8 +315,7 @@ mod tests {
     use super::*;
     #[test]
     fn checkbox() {
-        // FIXME: panics without newline
-        let input = "- [X]\n";
+        let input = "- [X]";
         let ret = parse_org(input);
         let item = expr_in_pool!(ret, Item).unwrap();
         assert_eq!(item.check_box, Some(CheckBox::On))
@@ -324,15 +323,60 @@ mod tests {
 
     #[test]
     fn counter_set() {
-        // FIXME: panics without newline
-        let input = "- [@1] \n";
+        let input = "- [@1]";
         let ret = parse_org(input);
         let item = expr_in_pool!(ret, Item).unwrap();
         assert_eq!(item.counter_set, Some("1"));
 
-        let input = "- [@43] \n";
+        let input = "- [@43]";
         let ret = parse_org(input);
         let item = expr_in_pool!(ret, Item).unwrap();
         assert_eq!(item.counter_set, Some("43"))
     }
+
+    #[test]
+    fn no_newline_hyphen() {
+        let input = "-";
+        let ret = parse_org(input);
+        let item = expr_in_pool!(ret, Plain).unwrap();
+        assert_eq!(item, &"-");
+    }
+    #[test]
+    fn hyphen_space() {
+        let input = "- ";
+        let ret = parse_org(input);
+        let item = expr_in_pool!(ret, Item).unwrap();
+    }
+
+    #[test]
+    fn hyphen_lbrack() {
+        let input = "- [";
+        let ret = parse_org(input);
+        let plain = expr_in_pool!(ret, Plain).unwrap();
+        assert_eq!(plain, &"[");
+    }
+    #[test]
+    fn hyphen_ltag() {
+        let input = "- [@";
+        let ret = parse_org(input);
+        let plain = expr_in_pool!(ret, Plain).unwrap();
+        assert_eq!(plain, &"[@");
+    }
+    #[test]
+    fn item_ordered_start() {
+        let input = "1. ";
+        let ret = parse_org(input);
+        let item = expr_in_pool!(ret, Item).unwrap();
+        assert!(matches!(item.bullet, BulletKind::Ordered(CounterKind::Number(1))));
+
+        let input = "17. ";
+        let ret = parse_org(input);
+        let item = expr_in_pool!(ret, Item).unwrap();
+        assert!(matches!(item.bullet, BulletKind::Ordered(CounterKind::Number(17))));
+
+        let input = "a. ";
+        let ret = parse_org(input);
+        let item = expr_in_pool!(ret, Item).unwrap();
+        assert!(matches!(item.bullet, BulletKind::Ordered(CounterKind::Letter(b'a'))));
+    }
 }

From 16a76d6e09280af0065b2b7fca1666cecc26e582 Mon Sep 17 00:00:00 2001
From: Laith <laithbahodi@gmail.com>
Date: Sat, 21 Sep 2024 17:06:25 -0400
Subject: [PATCH 07/14] feat: resilient headlines

the goal was to allow

* EOF

to be interpeted as a valid headline.this one was involved so i'll
provide some details:

1. extract title parsing to an external function so we can freely error
in case a title isnt provided
2. never panic on EOF, this was happening in two places
3. make the tests actually.. test

add make_node_id method for testing
---
 crates/org-parser/src/element/drawer.rs  |   5 +-
 crates/org-parser/src/element/heading.rs | 184 ++++++++++++++++++-----
 crates/org-parser/src/node_pool.rs       |   5 +
 3 files changed, 151 insertions(+), 43 deletions(-)

diff --git a/crates/org-parser/src/element/drawer.rs b/crates/org-parser/src/element/drawer.rs
index 7390656..705b0d5 100644
--- a/crates/org-parser/src/element/drawer.rs
+++ b/crates/org-parser/src/element/drawer.rs
@@ -30,7 +30,6 @@ impl<'a> Parseable<'a> for Drawer<'a> {
         parse_opts: ParseOpts,
     ) -> Result<NodeID> {
         let start = cursor.index;
-        cursor.curr_valid()?;
         cursor.skip_ws();
         cursor.word(":")?;
 
@@ -43,7 +42,7 @@ impl<'a> Parseable<'a> for Drawer<'a> {
         cursor.index = name_match.end;
         cursor.word(":")?;
         cursor.skip_ws();
-        if cursor.curr() != NEWLINE {
+        if cursor.try_curr()? != NEWLINE {
             return Err(MatchError::InvalidLogic);
         }
         cursor.next();
@@ -99,7 +98,7 @@ pub(crate) fn parse_property(mut cursor: Cursor) -> Result<Match<PropertyDrawer>
 
     cursor.word(":")?;
     cursor.skip_ws();
-    if cursor.curr() != NEWLINE {
+    if cursor.try_curr()? != NEWLINE {
         return Err(MatchError::InvalidLogic);
     }
     cursor.next();
diff --git a/crates/org-parser/src/element/heading.rs b/crates/org-parser/src/element/heading.rs
index 62a9195..7fb455a 100644
--- a/crates/org-parser/src/element/heading.rs
+++ b/crates/org-parser/src/element/heading.rs
@@ -1,3 +1,5 @@
+use std::rc::Rc;
+
 use crate::constants::{COLON, NEWLINE, RBRACK, SPACE, STAR};
 use crate::node_pool::NodeID;
 use crate::parse::{parse_element, parse_object};
@@ -128,32 +130,13 @@ impl<'a> Parseable<'a> for Heading<'a> {
 
         // try to trim whitespace off the beginning and end of the area
         // we're searching
-        let mut title_end = tag_match.start;
-        while cursor[title_end] == SPACE && title_end > cursor.index {
-            title_end -= 1;
-        }
-        let mut temp_cursor = cursor.cut_off(title_end + 1);
 
-        let mut target = None;
-        // FIXME: currently repeating work trimming hte beginning at skip_ws and with trim_start
-        let title = if bytes_to_str(temp_cursor.rest()).trim_start().is_empty() {
-            None
+        let (title, target) = if let Ok((title, target)) =
+            Heading::parse_title(parser, cursor, tag_match.start, reserved_id, parse_opts)
+        {
+            (title, target)
         } else {
-            let mut title_vec: Vec<NodeID> = Vec::new();
-
-            temp_cursor.skip_ws();
-            let title_start = temp_cursor.index;
-            while let Ok(title_id) =
-                parse_object(parser, temp_cursor, Some(reserved_id), parse_opts)
-            {
-                title_vec.push(title_id);
-                temp_cursor.move_to(parser.pool[title_id].end);
-            }
-
-            let title_entry = cursor.clamp(title_start, title_end + 1);
-            target = Some(parser.generate_target(title_entry));
-
-            Some((title_entry, title_vec))
+            (None, None)
         };
 
         // jump past the newline
@@ -354,15 +337,63 @@ impl<'a> Heading<'a> {
         }
         // we reached the start element, without hitting a space. no tags
     }
+
+    fn parse_title(
+        parser: &mut Parser<'a>,
+        cursor: Cursor<'a>,
+        mut title_end: usize,
+        reserved_id: NodeID,
+        parse_opts: ParseOpts,
+    ) -> Result<(Option<(&'a str, Vec<NodeID>)>, Option<Rc<str>>)> {
+        while let Some(item) = cursor.get(title_end).copied() {
+            if item == SPACE && title_end > cursor.index {
+                title_end -= 1;
+            } else {
+                break;
+            }
+        }
+        // alternative impl that does not accept titles that experience EOF, keeping here temporarily for posterity
+        // while cursor.get(title_end).ok_or(MatchError::EofError).copied()? == SPACE
+        //     && title_end > cursor.index
+        // {
+        //     title_end -= 1;
+        // }
+
+        let top_off = (title_end + 1).min(cursor.byte_arr.len());
+        let mut temp_cursor = cursor.cut_off(top_off);
+
+        // FIXME: currently repeating work trimming the beginning at skip_ws and with trim_start
+        if bytes_to_str(temp_cursor.rest()).trim_start().is_empty() {
+            Ok((None, None))
+        } else {
+            let mut title_vec: Vec<NodeID> = Vec::new();
+
+            temp_cursor.skip_ws();
+            let title_start = temp_cursor.index;
+            while let Ok(title_id) =
+                parse_object(parser, temp_cursor, Some(reserved_id), parse_opts)
+            {
+                title_vec.push(title_id);
+                temp_cursor.move_to(parser.pool[title_id].end);
+            }
+
+            let title_entry = cursor.clamp(title_start, top_off);
+            let target = Some(parser.generate_target(title_entry));
+
+            Ok((Some((title_entry, title_vec)), target))
+        }
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use std::borrow::Cow;
 
-    use crate::element::PropertyDrawer;
-    use crate::parse_org;
+    use crate::element::{HeadingLevel, PropertyDrawer, Tag};
+    use crate::node_pool::make_node_id;
     use crate::types::Expr;
+    use crate::{expr_in_pool, parse_org};
+    use pretty_assertions::assert_eq;
 
     use super::Heading;
 
@@ -430,8 +461,22 @@ mod tests {
     #[test]
     fn headline_title() {
         let inp = "*         title                                                \n";
-
-        dbg!(parse_org(inp));
+        let item = get_head(inp);
+        assert_eq!(
+            item,
+            Heading {
+                heading_level: HeadingLevel::One,
+                keyword: None,
+                priority: None,
+                title: Some((
+                    "title                                                \n",
+                    vec![make_node_id(2)]
+                )),
+                tags: None,
+                properties: None,
+                children: None
+            }
+        );
     }
 
     #[test]
@@ -473,31 +518,61 @@ mod tests {
     }
 
     #[test]
-    fn headline_tag() {
-        let inp = "* meow :tagone:\n";
+    fn headline_tag_one() {
+        let inp = "* cat :tagone:\n";
+        let head = get_head(inp);
 
-        dbg!(parse_org(inp));
+        assert_eq!(
+            head,
+            Heading {
+                heading_level: crate::element::HeadingLevel::One,
+                keyword: None,
+                priority: None,
+                title: Some(("cat", vec![make_node_id(2)])),
+                tags: Some(vec![Tag::Raw("tagone")]),
+                properties: None,
+                children: None,
+            }
+        );
     }
 
     #[test]
-    fn headline_tags() {
-        let inp = "* meow :tagone:tagtwo:\n";
+    fn headline_tag_two() {
+        let inp = "* test :tagone:tagtwo:\n";
+        let head = get_head(inp);
 
-        dbg!(parse_org(inp));
+        assert_eq!(
+            head,
+            Heading {
+                heading_level: crate::element::HeadingLevel::One,
+                keyword: None,
+                priority: None,
+                title: Some(("test", vec![make_node_id(2)])),
+                tags: Some(vec![Tag::Raw("tagtwo"), Tag::Raw("tagone")]),
+                properties: None,
+                children: None,
+            }
+        );
     }
 
     #[test]
-    fn headline_tags_bad() {
-        let inp = "* meow one:tagone:tagtwo:\n";
+    fn headline_tag_bad_one() {
+        let inp = "* abc one:tagone:tagtwo:\n";
 
-        dbg!(parse_org(inp));
+        let parsed = parse_org(inp);
+        let head = expr_in_pool!(parsed, Heading).unwrap();
+        assert_eq!(head.title.as_ref().unwrap().0, "abc one:tagone:tagtwo:\n");
+        assert_eq!(head.tags.as_ref(), None);
     }
 
     #[test]
-    fn headline_tags_bad2() {
-        let inp = "* meow :tagone::\n";
+    fn headline_tag_bad_two() {
+        let inp = "* abc :tagone::\n";
 
-        dbg!(parse_org(inp));
+        let parsed = parse_org(inp);
+        let head = expr_in_pool!(parsed, Heading).unwrap();
+        assert_eq!(head.title.as_ref().unwrap().0, "abc :tagone::\n");
+        assert_eq!(head.tags.as_ref(), None);
     }
 
     #[test]
@@ -598,4 +673,33 @@ aaaa";
         let pool = parse_org(input);
         pool.print_tree();
     }
+
+    #[test]
+    fn only_stars() {
+        let input = r"*** ";
+        let p = parse_org(input);
+        let item = expr_in_pool!(p, Heading).unwrap();
+
+        assert_eq!(item.heading_level, HeadingLevel::Three);
+    }
+
+    #[test]
+    fn only_stars_and_title() {
+        let input = "*** g";
+        let p = parse_org(input);
+        let item = expr_in_pool!(p, Heading).unwrap();
+
+        assert_eq!(
+            item,
+            &Heading {
+                heading_level: HeadingLevel::Three,
+                keyword: None,
+                priority: None,
+                title: Some(("g", vec![make_node_id(2)])),
+                tags: None,
+                properties: None,
+                children: None
+            }
+        );
+    }
 }
diff --git a/crates/org-parser/src/node_pool.rs b/crates/org-parser/src/node_pool.rs
index 7a55cf6..1f97562 100644
--- a/crates/org-parser/src/node_pool.rs
+++ b/crates/org-parser/src/node_pool.rs
@@ -10,6 +10,11 @@ use crate::types::{Expr, Node};
 /// sequentially and cannot re-used.
 pub struct NodeID(u32);
 
+/// This exists ONLY for testing purposes
+pub(crate) fn make_node_id(id: u32) -> NodeID {
+    NodeID(id)
+}
+
 impl Display for NodeID {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_fmt(format_args!("{}", self.0))

From 540eb36dd32ac54ad5664ff71467f23d6c4ac1eb Mon Sep 17 00:00:00 2001
From: Laith <laithbahodi@gmail.com>
Date: Sat, 21 Sep 2024 17:18:38 -0400
Subject: [PATCH 08/14] chore: fix tests

nothing breaking, i just updated the formatting a while ago and never
got around to resolving the errors it introduced in the tests
---
 crates/org-cli/src/template.rs             |  12 +--
 crates/org-exporter/src/html.rs            | 115 +++++++--------------
 crates/org-exporter/src/lib.rs             |  12 +--
 crates/org-parser/src/element/latex_env.rs |   2 +-
 4 files changed, 51 insertions(+), 90 deletions(-)

diff --git a/crates/org-cli/src/template.rs b/crates/org-cli/src/template.rs
index 43fd025..9836513 100644
--- a/crates/org-cli/src/template.rs
+++ b/crates/org-cli/src/template.rs
@@ -243,10 +243,10 @@ impl<'a, 'template> Template<'a, 'template> {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
+// #[cfg(test)]
+// mod tests {
+//     use super::*;
 
-    #[test]
-    fn bad_template() {}
-}
+//     #[test]
+//     fn bad_template() {}
+// }
diff --git a/crates/org-exporter/src/html.rs b/crates/org-exporter/src/html.rs
index 32eec60..d9520a3 100644
--- a/crates/org-exporter/src/html.rs
+++ b/crates/org-exporter/src/html.rs
@@ -612,21 +612,21 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                 }
             }
             Expr::PlainList(inner) => {
-                let tag = match inner.kind {
-                    ListKind::Unordered => "ul",
+                let (tag, desc) = match inner.kind {
+                    ListKind::Unordered => ("ul", ""),
                     ListKind::Ordered(counter_kind) => match counter_kind {
                         org_parser::element::CounterKind::Letter(c) => {
                             if c.is_ascii_uppercase() {
-                                r#"ol type="A""#
+                                ("ol", r#" type="A""#)
                             } else {
-                                r#"ol type="a""#
+                                ("ol", r#" type="a""#)
                             }
                         }
-                        org_parser::element::CounterKind::Number(_) => r#"ol type="1""#,
+                        org_parser::element::CounterKind::Number(_) => ("ol",r#" type="1""#),
                     },
-                    ListKind::Descriptive => "dd",
+                    ListKind::Descriptive => ("dd", ""),
                 };
-                write!(self, "<{tag}")?;
+                write!(self, "<{tag}{desc}")?;
                 self.prop(node)?;
                 writeln!(self, ">")?;
                 for id in &inner.children {
@@ -935,9 +935,7 @@ mod tests {
 
         assert_eq!(
             a,
-            r"<p>
-hiii cool three text
-</p>
+            r"<p>hiii cool three text</p>
 "
         );
 
@@ -955,9 +953,7 @@ hiii cool three text
 
         assert_eq!(
             a,
-            r"<p>
-hiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
-</p>
+            r"<p>hiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii</p>
 ",
         );
         Ok(())
@@ -972,10 +968,8 @@ hiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
 
         assert_eq!(
             a,
-            r"<p>
-abc
+            r"<p>abc
 <br>
-
 </p>
 ",
         );
@@ -987,9 +981,7 @@ abc
 
         assert_eq!(
             n,
-            r"<p>
-abc\\   q
-</p>
+            r"<p>abc\\   q</p>
 ",
         );
         Ok(())
@@ -1023,9 +1015,7 @@ abc\\   q
 
         assert_eq!(
             nb,
-            r"<p>
-----
-</p>
+            r"<p>----</p>
 ",
         );
 
@@ -1058,9 +1048,7 @@ abc &+ 10\\
 
         assert_eq!(
             a,
-            r"<p>
-a é😳
-</p>
+            r"<p>a é😳</p>
 "
         );
 
@@ -1077,10 +1065,8 @@ a é😳
 
         assert_eq!(
             a,
-            r#"<ol>
-<li value="4"><p>
-wordsss??
-</p>
+            r#"<ol type="1">
+<li value="4"><p>wordsss??</p>
 </li>
 </ol>
 "#,
@@ -1091,17 +1077,17 @@ wordsss??
     fn anon_footnote() -> Result {
         let a = html_export(
             r"
-hi [fn:next:coolio]
+hi [fn:next:coolio] yeah [fn:next]
 ",
         )?;
         // just codifying what the output is here, not supposed to be set in stone
         assert_eq!(
             a,
-            r##"<p>
-hi <sup>
+            r##"<p>hi <sup>
     <a id="fnr.1" href="#fn.1" class="footref" role="doc-backlink">1</a>
-</sup>
-</p>
+</sup> yeah <sup>
+    <a id="fnr.1.6" href="#fn.1" class="footref" role="doc-backlink">1</a>
+</sup></p>
 
 <div id="footnotes">
     <style>
@@ -1139,11 +1125,9 @@ hello [fn:1]
         // just codifying what the output is here, not supposed to be set in stone
         assert_eq!(
             a,
-            r##"<p>
-hello <sup>
+            r##"<p>hello <sup>
     <a id="fnr.1" href="#fn.1" class="footref" role="doc-backlink">1</a>
-</sup>
-</p>
+</sup></p>
 <h1 id="footnotes">Footnotes</h1>
 
 <div id="footnotes">
@@ -1159,9 +1143,7 @@ hello <sup>
 <sup>
     <a id="fn.1" href= "#fnr.1" role="doc-backlink">1</a>
 </sup>
-<p>
-world
-</p>
+<p>world</p>
 </div>
   </div>
 </div>"##
@@ -1193,8 +1175,7 @@ novel [fn:next:coolio]
         // had to change 1.7 to 1.8 to pass the test
         assert_eq!(
             a,
-            r##"<p>
-hi <sup>
+            r##"<p>hi <sup>
     <a id="fnr.1" href="#fn.1" class="footref" role="doc-backlink">1</a>
 </sup> cool test <sup>
     <a id="fnr.2" href="#fn.2" class="footref" role="doc-backlink">2</a>
@@ -1204,13 +1185,10 @@ hi <sup>
     <a id="fnr.3" href="#fn.3" class="footref" role="doc-backlink">3</a>
 </sup> again <sup>
     <a id="fnr.3.13" href="#fn.3" class="footref" role="doc-backlink">3</a>
-</sup>
-</p>
-<p>
-novel <sup>
+</sup></p>
+<p>novel <sup>
     <a id="fnr.4" href="#fn.4" class="footref" role="doc-backlink">4</a>
-</sup>
-</p>
+</sup></p>
 <h2 id="footnotes">Footnotes</h2>
 
 <div id="footnotes">
@@ -1226,27 +1204,21 @@ novel <sup>
 <sup>
     <a id="fn.1" href= "#fnr.1" role="doc-backlink">1</a>
 </sup>
-<p>
-abcdef
-</p>
+<p>abcdef</p>
 </div>
 
 <div class="footdef">
 <sup>
     <a id="fn.2" href= "#fnr.2" role="doc-backlink">2</a>
 </sup>
-<p>
-words babby
-</p>
+<p>words babby</p>
 </div>
 
 <div class="footdef">
 <sup>
     <a id="fn.3" href= "#fnr.3" role="doc-backlink">3</a>
 </sup>
-<p>
-hi
-</p>
+<p>hi</p>
 </div>
 
 <div class="footdef">
@@ -1274,19 +1246,13 @@ bad [fn:]
 
         assert_eq!(
             a,
-            r##"<p>
-And anonymous ones <sup>
+            r##"<p>And anonymous ones <sup>
     <a id="fnr.1" href="#fn.1" class="footref" role="doc-backlink">1</a>
-</sup>
-</p>
-<p>
-what <sup>
+</sup></p>
+<p>what <sup>
     <a id="fnr.2" href="#fn.2" class="footref" role="doc-backlink">2</a>
-</sup>
-</p>
-<p>
-bad [fn:]
-</p>
+</sup></p>
+<p>bad [fn:]</p>
 
 <div id="footnotes">
     <style>
@@ -1322,9 +1288,7 @@ mysterious</div>
 
         assert_eq!(
             a,
-            r#"<p>
-<a href="html.org">hi</a>
-</p>
+            r#"<p><a href="html.org">hi</a></p>
 "#
         );
 
@@ -1372,9 +1336,7 @@ mysterious</div>
 
         assert_eq!(
             a,
-            r##"<p>
-<a href="./hello">./hello</a>
-</p>
+            r##"<p><a href="./hello">./hello</a></p>
 "##
         );
 
@@ -1431,7 +1393,6 @@ content
 
 here
 "#;
-        dbg!(html_export(a));
-        assert_eq!(html_export(a).unwrap(), "love!");
+        assert_eq!(html_export(a).unwrap(), "<h1 id=\"yeah\">yeah</h1>\n<p>hello</p>\n<p>hi</p>\n<p>content</p>\n<p>here</p>\n");
     }
 }
diff --git a/crates/org-exporter/src/lib.rs b/crates/org-exporter/src/lib.rs
index c0157b3..a413151 100644
--- a/crates/org-exporter/src/lib.rs
+++ b/crates/org-exporter/src/lib.rs
@@ -8,23 +8,23 @@
 //!
 //! ```rust
 //! use org_rust_exporter as org_exporter;
-//! use org_exporter::{Html, Org, Exporter};
+//! use org_exporter::{Html, Org, Exporter, ConfigOptions};
 //!
-//! let html_str: String = Html::export("* Hello HTML!\n").unwrap();
-//! let org_str: String = Org::export("* Hello Org!\n").unwrap();
+//! let html_str: String = Html::export("* Hello HTML!\n", ConfigOptions::default()).unwrap();
+//! let org_str: String = Org::export("* Hello Org!\n", ConfigOptions::default()).unwrap();
 //! ```
 //!
 //! You can also export into a buffer that implements [`fmt::Write`]:
 //!
 //! ```rust
 //! use org_rust_exporter as org_exporter;
-//! use org_exporter::{Html, Org, Exporter};
+//! use org_exporter::{Html, Org, Exporter, ConfigOptions};
 //!
 //! let mut html_str = String::new();
 //! let mut org_str = String::new();
 //!
-//! Html::export_buf("* Hello HTML!\n", &mut html_str);
-//! Org::export_buf("* Hello Org!\n", &mut org_str);
+//! Html::export_buf("* Hello HTML!\n", &mut html_str, ConfigOptions::default());
+//! Org::export_buf("* Hello Org!\n", &mut org_str, ConfigOptions::default());
 //!
 //! assert_eq!(html_str, r#"<h1 id="hello-html">Hello HTML!</h1>
 //! "#);
diff --git a/crates/org-parser/src/element/latex_env.rs b/crates/org-parser/src/element/latex_env.rs
index a3736d8..0ac4028 100644
--- a/crates/org-parser/src/element/latex_env.rs
+++ b/crates/org-parser/src/element/latex_env.rs
@@ -27,7 +27,7 @@ impl<'a> Parseable<'a> for LatexEnv<'a> {
         let name = name_match.obj;
 
         let a = format!(r"(?m)^[ \t]*\\end{{{name}}}[\t ]*$");
-        // HACK: i simplt cannot figure out how to properly escape the curls in the regex.
+        // HACK/FIXME: i simply cannot figure out how to properly escape the curls in the regex.
         // always getting hit with:
         // error: repetition quantifier expects a valid decimal
         let a = a.replace("{", r"\{");

From f420620b57d7d33801467aab14cd77393fb07ade Mon Sep 17 00:00:00 2001
From: Laith <laithbahodi@gmail.com>
Date: Sun, 22 Sep 2024 01:34:56 -0400
Subject: [PATCH 09/14] feat: error types in exporter

include and macro handling in the export error now expose real errors,
not just yolo panicking and unwraps.
---
 crates/org-cli/src/cli.rs             |   2 +-
 crates/org-cli/src/utils.rs           |   2 +-
 crates/org-exporter/Cargo.toml        |   1 +
 crates/org-exporter/src/html.rs       | 111 +++++++++++++++-----------
 crates/org-exporter/src/include.rs    |  65 +++++++++++----
 crates/org-exporter/src/lib.rs        |   2 +-
 crates/org-exporter/src/org.rs        |  91 +++++++++++----------
 crates/org-exporter/src/org_macros.rs |  97 ++++++++++++++++------
 crates/org-exporter/src/types.rs      |  48 +++++++++--
 9 files changed, 283 insertions(+), 136 deletions(-)

diff --git a/crates/org-cli/src/cli.rs b/crates/org-cli/src/cli.rs
index f2341d1..ec61813 100644
--- a/crates/org-cli/src/cli.rs
+++ b/crates/org-cli/src/cli.rs
@@ -51,7 +51,7 @@ impl Backend {
         parsed: &org_parser::Parser,
         buf: &mut String,
         conf: ConfigOptions
-    ) -> Result<(), core::fmt::Error> {
+    ) -> Result<(), org_exporter::ExportError> {
         match self {
             Backend::Html => org_exporter::Html::export_tree(parsed, buf, conf),
             Backend::Org => org_exporter::Org::export_tree(parsed, buf, conf),
diff --git a/crates/org-cli/src/utils.rs b/crates/org-cli/src/utils.rs
index e5a2042..21c5336 100644
--- a/crates/org-cli/src/utils.rs
+++ b/crates/org-cli/src/utils.rs
@@ -8,7 +8,7 @@ use crate::types::CliError;
 // a fs::canonicalize that doesnt care for existince. used for error handling
 // yanked straight from:
 // https://github.com/rust-lang/cargo/blob/fede83ccf973457de319ba6fa0e36ead454d2e20/src/cargo/util/paths.rs#L61
-pub fn normalize_path(path: &Path) -> PathBuf {
+pub fn _normalize_path(path: &Path) -> PathBuf {
     let mut components = path.components().peekable();
     let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() {
         components.next();
diff --git a/crates/org-exporter/Cargo.toml b/crates/org-exporter/Cargo.toml
index 18fa06b..df2b407 100644
--- a/crates/org-exporter/Cargo.toml
+++ b/crates/org-exporter/Cargo.toml
@@ -16,6 +16,7 @@ latex2mathml = "0.2.3"
 memchr = "2.5.0"
 org-parser = { version = "0.1.3", path = "../org-parser", package = "org-rust-parser" }
 phf = {version = "0.11.1", features = ["macros"]}
+thiserror = "1.0.63"
 
 [dev-dependencies]
 pretty_assertions = "1.3.0"
diff --git a/crates/org-exporter/src/html.rs b/crates/org-exporter/src/html.rs
index d9520a3..43feefa 100644
--- a/crates/org-exporter/src/html.rs
+++ b/crates/org-exporter/src/html.rs
@@ -5,7 +5,7 @@
 use core::fmt;
 use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
-use std::fmt::{Result, Write};
+use std::fmt::Write;
 
 use latex2mathml::{latex_to_mathml, DisplayStyle};
 use memchr::memchr3_iter;
@@ -15,8 +15,9 @@ use org_parser::{parse_macro_call, parse_org, Expr, Node, NodeID, Parser};
 
 use crate::include::include_handle;
 use crate::org_macros::macro_handle;
-use crate::types::{ConfigOptions, Exporter, ExporterInner};
+use crate::types::{ConfigOptions, Exporter, ExporterInner, LogicErrorKind, Result};
 use crate::utils::{process_toc, Options, TocItem};
+use crate::ExportError;
 use phf::phf_set;
 
 // file types we can wrap an `img` around
@@ -83,7 +84,7 @@ impl<'a, S: AsRef<str>> fmt::Display for HtmlEscape<S> {
     // we can iterate over bytes since it's not possible for
     // an ascii character to appear in the codepoint of another larger char
     // if we see an ascii, then it's guaranteed to be valid
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut prev_pos = 0;
         // there are other characters we could escape, but memchr caps out at 3
         // the really important one is `<`, and then also probably &
@@ -113,7 +114,7 @@ impl<'a, S: AsRef<str>> fmt::Display for HtmlEscape<S> {
 }
 
 impl<'buf> Exporter<'buf> for Html<'buf> {
-    fn export(input: &str, conf: ConfigOptions) -> core::result::Result<String, fmt::Error> {
+    fn export(input: &str, conf: ConfigOptions) -> Result<String> {
         let mut buf = String::new();
         Html::export_buf(input, &mut buf, conf)?;
         Ok(buf)
@@ -123,7 +124,7 @@ impl<'buf> Exporter<'buf> for Html<'buf> {
         input: &'inp str,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> Result {
+    ) -> Result<()> {
         let parsed: Parser<'_> = parse_org(input);
         Html::export_tree(&parsed, buf, conf)
     }
@@ -132,7 +133,7 @@ impl<'buf> Exporter<'buf> for Html<'buf> {
         parsed: &Parser,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> fmt::Result {
+    ) -> Result<()> {
         let mut obj = Html {
             buf,
             nox: HashSet::new(),
@@ -168,7 +169,7 @@ fn toc_rec<'a, T: fmt::Write + ExporterInner<'a>>(
     writer: &mut T,
     parent: &TocItem,
     curr_level: u8,
-) -> Result {
+) -> Result<()> {
     write!(writer, "<li>")?;
     if curr_level < parent.level {
         write!(writer, "<ul>")?;
@@ -188,7 +189,9 @@ fn toc_rec<'a, T: fmt::Write + ExporterInner<'a>>(
             write!(writer, "</ul>")?;
         }
     }
-    write!(writer, "</li>")
+    write!(writer, "</li>")?;
+
+    Ok(())
 }
 
 impl<'buf> ExporterInner<'buf> for Html<'buf> {
@@ -196,7 +199,7 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
         input: &'inp str,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> Result {
+    ) -> Result<()> {
         let parsed = parse_macro_call(input);
         let mut obj = Html {
             buf,
@@ -209,7 +212,7 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
         obj.export_rec(&parsed.pool.root_id(), &parsed)
     }
 
-    fn export_rec(&mut self, node_id: &NodeID, parser: &Parser) -> Result {
+    fn export_rec(&mut self, node_id: &NodeID, parser: &Parser) -> Result<()> {
         // avoid parsing this node
         if self.nox.contains(node_id) {
             return Ok(());
@@ -532,11 +535,15 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
             }
             Expr::Keyword(inner) => {
                 if inner.key.to_ascii_lowercase() == "include" {
-                    // FIXME: proper error handling
                     write!(self, r#"<div class="org-include""#)?;
                     self.prop(node)?;
                     write!(self, ">")?;
-                    include_handle(inner.val, self).unwrap();
+
+                    // TODO have vec to store errors instead of blowing up
+                    include_handle(inner.val, self).map_err(|e| ExportError::LogicError {
+                        span: node.start..node.end,
+                        source: LogicErrorKind::Include(e),
+                    })?;
                     write!(self, "</div>")?;
                 }
             }
@@ -622,7 +629,7 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                                 ("ol", r#" type="a""#)
                             }
                         }
-                        org_parser::element::CounterKind::Number(_) => ("ol",r#" type="1""#),
+                        org_parser::element::CounterKind::Number(_) => ("ol", r#" type="1""#),
                     },
                     ListKind::Descriptive => ("dd", ""),
                 };
@@ -718,14 +725,20 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                 )?;
             }
             Expr::Macro(macro_call) => {
-                if let Ok(macro_contents) = macro_handle(parser, macro_call, self.config_opts()) {
-                    match macro_contents {
-                        Cow::Owned(p) => {
-                            Html::export_macro_buf(&p, self, self.config_opts().clone())?;
-                        }
-                        Cow::Borrowed(r) => {
-                            write!(self, "{}", HtmlEscape(r))?;
+                let macro_contents =
+                    macro_handle(parser, macro_call, self.config_opts()).map_err(|e| {
+                        ExportError::LogicError {
+                            span: node.start..node.end,
+                            source: LogicErrorKind::Macro(e),
                         }
+                    })?;
+
+                match macro_contents {
+                    Cow::Owned(p) => {
+                        Html::export_macro_buf(&p, self, self.config_opts().clone())?;
+                    }
+                    Cow::Borrowed(r) => {
+                        write!(self, "{}", HtmlEscape(r))?;
                     }
                 }
             }
@@ -814,7 +827,7 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
 // Writers for generic attributes
 impl<'buf> Html<'buf> {
     /// Adds a property
-    fn prop(&mut self, node: &Node) -> Result {
+    fn prop(&mut self, node: &Node) -> Result<()> {
         // if the target needs an id
         if let Some(tag_contents) = node.id_target.as_ref() {
             write!(self, r#" id="{tag_contents}""#)?;
@@ -830,15 +843,17 @@ impl<'buf> Html<'buf> {
         Ok(())
     }
 
-    fn class(&mut self, name: &str) -> Result {
-        write!(self, r#" class="{name}""#)
+    fn class(&mut self, name: &str) -> Result<()> {
+        write!(self, r#" class="{name}""#)?;
+        Ok(())
     }
 
-    fn attr(&mut self, key: &str, val: &str) -> Result {
-        write!(self, r#" {}="{}""#, key, HtmlEscape(val))
+    fn attr(&mut self, key: &str, val: &str) -> Result<()> {
+        write!(self, r#" {}="{}""#, key, HtmlEscape(val))?;
+        Ok(())
     }
 
-    fn exp_footnotes(&mut self, parser: &Parser) -> Result {
+    fn exp_footnotes(&mut self, parser: &Parser) -> Result<()> {
         if self.footnotes.is_empty() {
             return Ok(());
         }
@@ -907,12 +922,13 @@ impl<'buf> Html<'buf> {
             }
             write!(self, r#"</div>"#)?;
         }
-        write!(self, "\n  </div>\n</div>")
+        write!(self, "\n  </div>\n</div>")?;
+        Ok(())
     }
 }
 
 impl fmt::Write for Html<'_> {
-    fn write_str(&mut self, s: &str) -> Result {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
         self.buf.write_str(s)
     }
 }
@@ -922,11 +938,11 @@ mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
 
-    fn html_export(input: &str) -> core::result::Result<String, fmt::Error> {
+    fn html_export(input: &str) -> Result<String> {
         Html::export(input, ConfigOptions::default())
     }
     #[test]
-    fn combined_macros() -> fmt::Result {
+    fn combined_macros() -> Result<()> {
         let a = html_export(
             r"#+macro: poem hiii $1 $2 text
 {{{poem(cool,three)}}}
@@ -943,7 +959,7 @@ mod tests {
     }
 
     #[test]
-    fn keyword_macro() -> Result {
+    fn keyword_macro() -> Result<()> {
         let a = html_export(
             r"
      #+title: hiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
@@ -960,7 +976,7 @@ mod tests {
     }
 
     #[test]
-    fn line_break() -> Result {
+    fn line_break() -> Result<()> {
         let a = html_export(
             r" abc\\
 ",
@@ -988,7 +1004,7 @@ mod tests {
     }
 
     #[test]
-    fn horizontal_rule() -> Result {
+    fn horizontal_rule() -> Result<()> {
         let a = html_export(
             r"-----
 ",
@@ -1023,7 +1039,7 @@ mod tests {
     }
 
     #[test]
-    fn correct_cache() -> Result {
+    fn correct_cache() -> Result<()> {
         let a = html_export(
             r"
 - one
@@ -1040,7 +1056,7 @@ abc &+ 10\\
     }
 
     #[test]
-    fn html_unicode() -> Result {
+    fn html_unicode() -> Result<()> {
         let a = html_export(
             r"a é😳
 ",
@@ -1056,7 +1072,7 @@ abc &+ 10\\
     }
 
     #[test]
-    fn list_counter_set() -> Result {
+    fn list_counter_set() -> Result<()> {
         let a = html_export(
             r"
 1. [@4] wordsss??
@@ -1074,7 +1090,7 @@ abc &+ 10\\
         Ok(())
     }
     #[test]
-    fn anon_footnote() -> Result {
+    fn anon_footnote() -> Result<()> {
         let a = html_export(
             r"
 hi [fn:next:coolio] yeah [fn:next]
@@ -1111,7 +1127,7 @@ coolio</div>
     }
 
     #[test]
-    fn footnote_heading() -> Result {
+    fn footnote_heading() -> Result<()> {
         let a = html_export(
             r"
 hello [fn:1]
@@ -1152,7 +1168,7 @@ hello [fn:1]
     }
 
     #[test]
-    fn footnote_order() -> Result {
+    fn footnote_order() -> Result<()> {
         // tests dupes too
         let a = html_export(
             r#"
@@ -1233,7 +1249,7 @@ coolio</div>
     }
 
     #[test]
-    fn esoteric_footnotes() -> Result {
+    fn esoteric_footnotes() -> Result<()> {
         let a = html_export(
             r"
 And anonymous ones [fn::mysterious]
@@ -1283,7 +1299,7 @@ mysterious</div>
     }
 
     #[test]
-    fn file_link() -> Result {
+    fn file_link() -> Result<()> {
         let a = html_export(r"[[file:html.org][hi]]")?;
 
         assert_eq!(
@@ -1296,7 +1312,7 @@ mysterious</div>
     }
 
     #[test]
-    fn file_link_image() -> Result {
+    fn file_link_image() -> Result<()> {
         let a = html_export(
             r"
 [[file:bmc.jpg]]
@@ -1313,7 +1329,7 @@ mysterious</div>
     }
 
     #[test]
-    fn basic_link_image() -> Result {
+    fn basic_link_image() -> Result<()> {
         let a = html_export(
             r"
 [[https://upload.wikimedia.org/wikipedia/commons/a/a6/Org-mode-unicorn.svg]]
@@ -1331,7 +1347,7 @@ mysterious</div>
     }
 
     #[test]
-    fn unspecified_link() -> Result {
+    fn unspecified_link() -> Result<()> {
         let a = html_export(r"[[./hello]]")?;
 
         assert_eq!(
@@ -1344,7 +1360,7 @@ mysterious</div>
     }
 
     #[test]
-    fn checkbox() -> Result {
+    fn checkbox() -> Result<()> {
         let a = html_export("- [X]\n")?;
 
         assert_eq!(
@@ -1393,6 +1409,9 @@ content
 
 here
 "#;
-        assert_eq!(html_export(a).unwrap(), "<h1 id=\"yeah\">yeah</h1>\n<p>hello</p>\n<p>hi</p>\n<p>content</p>\n<p>here</p>\n");
+        assert_eq!(
+            html_export(a).unwrap(),
+            "<h1 id=\"yeah\">yeah</h1>\n<p>hello</p>\n<p>hi</p>\n<p>content</p>\n<p>here</p>\n"
+        );
     }
 }
diff --git a/crates/org-exporter/src/include.rs b/crates/org-exporter/src/include.rs
index 29ff1b3..7e88189 100644
--- a/crates/org-exporter/src/include.rs
+++ b/crates/org-exporter/src/include.rs
@@ -26,13 +26,14 @@
 use org_parser::parse_org;
 use std::borrow::Cow;
 use std::fs::read_to_string;
+use std::num::ParseIntError;
 use std::ops::Range;
 use std::path::Path;
+use thiserror::Error;
 
 use org_parser::element::HeadingLevel;
 
-use crate::types::ExporterInner;
-use crate::ConfigOptions;
+use crate::types::{ExportError, ExporterInner, FileError};
 
 /// Block types that correspond directly to types within the parser.
 #[derive(Debug)]
@@ -59,13 +60,13 @@ pub(crate) struct InclParams<'a> {
 
 impl<'a> InclParams<'a> {
     // TODO; make error handling less... weird
-    fn new(value: &'a str) -> Result<Self, Box<dyn std::error::Error>> {
+    fn new(value: &'a str) -> Result<Self, IncludeError> {
         // peekable so we don't accidentally consume :kwarg params when expecting
         // positional arguments
         let mut params = value.split(" ").peekable();
 
         let provided_path;
-        let file_chunk = params.next().ok_or("No file provided")?;
+        let file_chunk = params.next().ok_or(IncludeError::NoFile)?;
 
         // TODO: searching through file
         // account for search options
@@ -100,7 +101,7 @@ impl<'a> InclParams<'a> {
                     };
                     IncludeBlock::Src { lang }
                 }
-                _ => Err(format!("Invalid block name {}", potential_block))?,
+                _ => Err(IncludeError::UnsupportedBlock(potential_block.into()))?,
             })
         } else {
             None
@@ -128,9 +129,9 @@ impl<'a> InclParams<'a> {
                         let start: usize;
                         let end: usize;
 
-                        let hyphen_ind = not_kwarg
-                            .find('-')
-                            .ok_or("Lines pattern does not contain '-'")?;
+                        let hyphen_ind = not_kwarg.find('-').ok_or(IncludeError::InvalidSyntax(
+                            "Lines pattern does not contain '-'".into(),
+                        ))?;
 
                         start = if hyphen_ind == 0 {
                             0
@@ -158,11 +159,11 @@ impl<'a> InclParams<'a> {
                             4 => Some(HeadingLevel::Four),
                             5 => Some(HeadingLevel::Five),
                             6 => Some(HeadingLevel::Six),
-                            _ => Err(format!("Invalid heading level {}", temp))?,
+                            _ => Err(IncludeError::InvalidMinLevel { received: temp })?,
                         };
                     }
                 }
-                _ => Err(format!("Invalid kwarg name {}", kwarg))?,
+                _ => Err(IncludeError::UnsupportedKwarg(kwarg.into()))?,
             }
         }
 
@@ -186,17 +187,29 @@ impl<'a> InclParams<'a> {
 pub(crate) fn include_handle<'a>(
     value: &str,
     writer: &mut impl ExporterInner<'a>,
-) -> Result<(), Box<dyn std::error::Error>> {
+) -> core::result::Result<(), IncludeError> {
     let ret = InclParams::new(value)?;
     // REVIEW: little uncomfortable reding the full string in before
     // processing lines
     let target_path: Cow<Path> = if let Some(v) = writer.config_opts().file_path().as_ref() {
         // TODO: error handling
-        v.parent().unwrap().join(ret.file).canonicalize()?.into()
+        let temp_path = v.parent().unwrap().join(ret.file);
+        temp_path
+            .canonicalize()
+            .map_err(|e| FileError {
+                context: "failed to locate file".into(),
+                path: temp_path,
+                source: e,
+            })?
+            .into()
     } else {
         ret.file.into()
     };
-    let mut out_str = read_to_string(target_path)?;
+    let mut out_str = read_to_string(&target_path).map_err(|e| FileError {
+        context: "failed to read file".into(),
+        path: target_path.into(),
+        source: e,
+    })?;
     if let Some(lines) = ret.lines {
         out_str = out_str
             .lines()
@@ -262,7 +275,31 @@ pub(crate) fn include_handle<'a>(
     // TODO: only-contents
 
     parsed = parse_org(&feed_str);
-    writer.export_rec(&parsed.pool.root_id(), &parsed)?;
+    writer
+        .export_rec(&parsed.pool.root_id(), &parsed)
+        .map_err(|e| Box::new(e))?;
 
     Ok(())
 }
+
+#[derive(Debug, Error)]
+pub enum IncludeError {
+    #[error("Invalid include syntax: {0}")]
+    InvalidSyntax(String),
+    #[error("No file provided")]
+    NoFile,
+    #[error("block `{0}` is not one of [export, example, src]")]
+    UnsupportedBlock(String),
+    #[error("kwarg `{0}` is not one of [:only-contents, :lines, :minlevel]")]
+    UnsupportedKwarg(String),
+    #[error("lines provided are not in base 10: {0}")]
+    LinesError(#[from] ParseIntError),
+    #[error("expected a minlevel of 1-6, received: {received}")]
+    InvalidMinLevel { received: usize },
+    #[error("minlevel was not a number: {0}")]
+    NotStringMinlevel(String),
+    #[error("{0}")]
+    IoError(#[from] FileError),
+    #[error("{0}")]
+    FileExport(#[from] Box<ExportError>),
+}
diff --git a/crates/org-exporter/src/lib.rs b/crates/org-exporter/src/lib.rs
index a413151..db19f59 100644
--- a/crates/org-exporter/src/lib.rs
+++ b/crates/org-exporter/src/lib.rs
@@ -40,4 +40,4 @@ mod utils;
 
 pub use html::Html;
 pub use org::Org;
-pub use types::{Exporter, ConfigOptions};
+pub use types::{ConfigOptions, ExportError, Exporter};
diff --git a/crates/org-exporter/src/org.rs b/crates/org-exporter/src/org.rs
index 362afe0..e83cd7a 100644
--- a/crates/org-exporter/src/org.rs
+++ b/crates/org-exporter/src/org.rs
@@ -4,7 +4,8 @@ use std::fmt::Write;
 
 use crate::include::include_handle;
 use crate::org_macros::macro_handle;
-use crate::types::{ConfigOptions, Exporter, ExporterInner};
+use crate::types::{ConfigOptions, Exporter, ExporterInner, LogicErrorKind, Result};
+use crate::ExportError;
 use org_parser::element::{Block, BulletKind, CounterKind, Priority, TableRow, Tag};
 use org_parser::object::{LatexFragment, PlainOrRec};
 
@@ -22,10 +23,11 @@ pub struct Org<'buf> {
     indentation_level: u8,
     on_newline: bool,
     conf: ConfigOptions,
+    // errors: Vec<ExportError>,
 }
 
 impl<'buf> Exporter<'buf> for Org<'buf> {
-    fn export(input: &str, conf: ConfigOptions) -> core::result::Result<String, fmt::Error> {
+    fn export(input: &str, conf: ConfigOptions) -> Result<String> {
         let mut buf = String::new();
         Org::export_buf(input, &mut buf, conf)?;
         Ok(buf)
@@ -35,7 +37,7 @@ impl<'buf> Exporter<'buf> for Org<'buf> {
         input: &'inp str,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> fmt::Result {
+    ) -> Result<()> {
         let parsed = parse_org(input);
         Org::export_tree(&parsed, buf, conf)
     }
@@ -44,7 +46,7 @@ impl<'buf> Exporter<'buf> for Org<'buf> {
         parsed: &Parser,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> fmt::Result {
+    ) -> Result<()> {
         let mut obj = Org {
             buf,
             indentation_level: 0,
@@ -61,7 +63,7 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
         input: &'inp str,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> fmt::Result {
+    ) -> Result<()> {
         let parsed = org_parser::parse_macro_call(input);
 
         let mut obj = Org {
@@ -74,8 +76,9 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
         obj.export_rec(&parsed.pool.root_id(), &parsed)
     }
 
-    fn export_rec(&mut self, node_id: &NodeID, parser: &Parser) -> fmt::Result {
-        match &parser.pool[*node_id].obj {
+    fn export_rec(&mut self, node_id: &NodeID, parser: &Parser) -> Result<()> {
+        let node = &parser.pool[*node_id];
+        match &node.obj {
             Expr::Root(inner) => {
                 for id in inner {
                     self.export_rec(id, parser)?;
@@ -338,8 +341,10 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
             }
             Expr::Keyword(inner) => {
                 if inner.key.to_ascii_lowercase() == "include" {
-                    // FIXME: proper error handling
-                    include_handle(inner.val, self).unwrap();
+                    include_handle(inner.val, self).map_err(|e| ExportError::LogicError {
+                        span: node.start..node.end,
+                        source: LogicErrorKind::Include(e),
+                    })?;
                 }
             }
             Expr::LatexEnv(inner) => {
@@ -553,14 +558,20 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                 write!(self, "<<{}>>", inner.0)?;
             }
             Expr::Macro(macro_call) => {
-                if let Ok(macro_contents) = macro_handle(parser, macro_call, self.config_opts()) {
-                    match macro_contents {
-                        Cow::Owned(p) => {
-                            Org::export_macro_buf(&p, self, self.config_opts().clone())?;
-                        }
-                        Cow::Borrowed(r) => {
-                            write!(self, "{r}")?;
+                let macro_contents =
+                    macro_handle(parser, macro_call, self.config_opts()).map_err(|e| {
+                        ExportError::LogicError {
+                            span: node.start..node.end,
+                            source: LogicErrorKind::Macro(e),
                         }
+                    })?;
+
+                match macro_contents {
+                    Cow::Owned(p) => {
+                        Org::export_macro_buf(&p, self, self.config_opts().clone())?;
+                    }
+                    Cow::Borrowed(r) => {
+                        write!(self, "{r}")?;
                     }
                 }
             }
@@ -640,15 +651,15 @@ impl<'buf> fmt::Write for Org<'buf> {
 mod tests {
     use super::*;
 
-    use fmt::Result;
+    use crate::types::Result;
     use pretty_assertions::assert_eq;
 
-    fn org_export(input: &str) -> core::result::Result<String, fmt::Error> {
+    fn org_export(input: &str) -> Result<String> {
         Org::export(input, ConfigOptions::default())
     }
 
     #[test]
-    fn basic_org_export() -> Result {
+    fn basic_org_export() -> Result<()> {
         let out_str = org_export(
             r"** one two
 three
@@ -668,7 +679,7 @@ three *four*
     }
 
     #[test]
-    fn fancy_list_export() -> Result {
+    fn fancy_list_export() -> Result<()> {
         let a = org_export(
             r"
     + one two three
@@ -698,14 +709,14 @@ four five six
     }
 
     #[test]
-    fn test_link_export() -> Result {
+    fn test_link_export() -> Result<()> {
         let out = org_export("[[https://swag.org][meowww]]")?;
         println!("{out}");
         Ok(())
     }
 
     #[test]
-    fn test_beeg() -> Result {
+    fn test_beeg() -> Result<()> {
         let out = org_export(
             r"* DONE [#0] *one* two /three/ /four*       :one:two:three:four:
 more content here this is a pargraph
@@ -845,7 +856,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn less() -> Result {
+    fn less() -> Result<()> {
         let out = org_export(
             r"* [#1] abc :c:
 ** [#1] descendant headline :a:b:
@@ -867,7 +878,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn list_export() -> Result {
+    fn list_export() -> Result<()> {
         let a = org_export(
             r"
 - one
@@ -898,7 +909,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn basic_list_export() -> Result {
+    fn basic_list_export() -> Result<()> {
         let a = org_export(
             r"
 - one
@@ -931,7 +942,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn list_words() -> Result {
+    fn list_words() -> Result<()> {
         let a: String = org_export(
             r"
 1. item 1
@@ -971,7 +982,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn table_export() -> Result {
+    fn table_export() -> Result<()> {
         let a = org_export(
             r"
 |one|two|
@@ -995,7 +1006,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn table_export_hrule() -> Result {
+    fn table_export_hrule() -> Result<()> {
         let a = org_export(
             r"
 |one|two|
@@ -1029,7 +1040,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn indented_table() -> Result {
+    fn indented_table() -> Result<()> {
         let a = org_export(
             r"
 - zero
@@ -1065,7 +1076,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn proper_list_indent() -> Result {
+    fn proper_list_indent() -> Result<()> {
         let a = org_export(
             r"
 - one
@@ -1088,7 +1099,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn heading_list_not() -> Result {
+    fn heading_list_not() -> Result<()> {
         let a = org_export(
             r"
 - one
@@ -1112,7 +1123,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn proper_link() -> Result {
+    fn proper_link() -> Result<()> {
         let a = org_export(r"[[abc][one]]")?;
 
         assert_eq!(
@@ -1125,7 +1136,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn link_odd() -> Result {
+    fn link_odd() -> Result<()> {
         let a = org_export("[aayyyy][one]]")?;
         assert_eq!(
             a,
@@ -1136,7 +1147,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn superscript() -> Result {
+    fn superscript() -> Result<()> {
         let a = org_export(r"sample_text^{\gamma}")?;
         assert_eq!(
             a,
@@ -1167,7 +1178,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn subscript() -> Result {
+    fn subscript() -> Result<()> {
         let a = org_export(r"sample_text_{\gamma}")?;
         assert_eq!(
             a,
@@ -1198,7 +1209,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn plain_link() -> Result {
+    fn plain_link() -> Result<()> {
         let a = org_export("https://cool.com abc rest")?;
 
         assert_eq!(
@@ -1210,7 +1221,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn newline_literal_markup() -> Result {
+    fn newline_literal_markup() -> Result<()> {
         let a = org_export(
             r"- test =if ~literal $interpreters \[handle newline \(properly {{{in(a lists
 - text that isn't disappearing!
@@ -1228,7 +1239,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn lblock_plus_list() -> Result {
+    fn lblock_plus_list() -> Result<()> {
         let a = org_export(
             r"
 -
@@ -1249,7 +1260,7 @@ meowwwwwwwwww
     }
 
     #[test]
-    fn markup_enclosed_in_bracks() -> Result {
+    fn markup_enclosed_in_bracks() -> Result<()> {
         let a = org_export(r"[_enclosed text here_]")?;
 
         assert_eq!(
@@ -1262,7 +1273,7 @@ meowwwwwwwwww
     }
 
     #[test]
-    fn drawer() -> Result {
+    fn drawer() -> Result<()> {
         let a = org_export(
             r"
 :NAME:
diff --git a/crates/org-exporter/src/org_macros.rs b/crates/org-exporter/src/org_macros.rs
index 53ef220..78e511b 100644
--- a/crates/org-exporter/src/org_macros.rs
+++ b/crates/org-exporter/src/org_macros.rs
@@ -5,6 +5,9 @@ use std::borrow::Cow;
 use std::fs::read_to_string;
 use std::path::Path;
 
+use thiserror::Error;
+
+use crate::types::FileError;
 use crate::utils::keyword_lookup;
 use crate::ConfigOptions;
 
@@ -12,10 +15,26 @@ pub(crate) fn macro_handle<'a>(
     parser: &'a Parser,
     macro_call: &'a MacroCall,
     config: &ConfigOptions,
-) -> Result<Cow<'a, str>, Box<dyn std::error::Error>> {
+) -> Result<Cow<'a, str>, MacroError> {
     match macro_call.name {
-        "keyword" => keyword_macro(parser, &macro_call.args[0]),
-        "kw-file" => keyword_file(&macro_call.args[0], &macro_call.args[1], config),
+        "keyword" => {
+            if macro_call.args.len() != 1 {
+                Err(MacroError::InvalidParameters {
+                    expected: 1,
+                    received: macro_call.args.len(),
+                })?
+            }
+            keyword_macro(parser, &macro_call.args[0])
+        }
+        "kw-file" => {
+            if macro_call.args.len() != 2 {
+                Err(MacroError::InvalidParameters {
+                    expected: 2,
+                    received: macro_call.args.len(),
+                })?
+            }
+            keyword_file(&macro_call.args[0], &macro_call.args[1], config)
+        }
         special_keyword @ ("title" | "author" | "email") => {
             if macro_call.args.is_empty() {
                 keyword_macro(parser, special_keyword)
@@ -30,16 +49,21 @@ pub(crate) fn macro_handle<'a>(
 pub(crate) fn macro_execute<'a>(
     parser: &'a Parser,
     macro_call: &MacroCall<'a>,
-) -> Result<Cow<'a, str>, Box<dyn std::error::Error>> {
-    let mac_def = parser.macros.get(macro_call.name).unwrap();
-    // FIXME: pretty janky, but have to do this dance to get the macrodef for the macrocall
+) -> Result<Cow<'a, str>, MacroError> {
+    let mac_def = parser
+        .macros
+        .get(macro_call.name)
+        .ok_or(MacroError::UndefinedMacro {
+            name: macro_call.name.into(),
+        })?;
 
-    // if let Expr::MacroDef(mac_def) = &parser.pool[*macid].obj {
-    if macro_call.args.len() == mac_def.num_args as usize {
-        Ok(apply(mac_def, &macro_call.args))
-    } else {
-        unreachable!("darn")
+    if macro_call.args.len() != mac_def.num_args as usize {
+        Err(MacroError::InvalidParameters {
+            expected: mac_def.num_args as usize,
+            received: macro_call.args.len(),
+        })?
     }
+    Ok(apply(mac_def, &macro_call.args))
 
     // }
 }
@@ -70,34 +94,55 @@ pub fn apply<'a>(macro_def: &MacroDef, args: &[Cow<'a, str>]) -> Cow<'a, str> {
 pub(crate) fn keyword_macro<'a>(
     parser: &'a Parser,
     name: &'a str,
-) -> Result<Cow<'a, str>, Box<dyn std::error::Error>> {
-    // not finding a keyword doesn't blow up the exporter in org-mode
-    //
-    // TODO: warning system so invalid macros are caught
-    Ok(keyword_lookup(parser, name)
+) -> Result<Cow<'a, str>, MacroError> {
+    keyword_lookup(parser, name)
         .map(|x| x.into())
-        .expect("whoops"))
+        .ok_or(MacroError::Keyword { kw: name.into() })
 }
 
-pub fn keyword_file<'a>(
+pub(crate) fn keyword_file<'a>(
     kw: &'a str,
     file: &'a str,
     config: &ConfigOptions,
-) -> Result<Cow<'a, str>, Box<dyn std::error::Error>> {
+) -> Result<Cow<'a, str>, MacroError> {
     let path = Path::new(file.trim());
 
     let target_path: Cow<Path> = if let Some(v) = config.file_path().as_ref() {
         // TODO: error handling
-        v.parent().unwrap().join(path).canonicalize()?.into()
+        let temp_path = v.parent().unwrap().join(path);
+        temp_path
+            .canonicalize()
+            .map_err(|e| FileError {
+                context: "failed to locate file".into(),
+                path: temp_path,
+                source: e,
+            })?
+            .into()
     } else {
         path.into()
     };
 
-    let out_str = read_to_string(target_path)?;
+    let out_str = read_to_string(&target_path).map_err(|e| FileError {
+        context: "failed to read file".into(),
+        path: target_path.into(),
+        source: e,
+    })?;
     let parsed = org_parser::parse_org(&out_str);
-    if let Some(&val) = parsed.keywords.get(kw) {
-        Ok(Cow::from(val.to_owned()))
-    } else {
-        todo!("whoopsies")
-    }
+    parsed
+        .keywords
+        .get(kw)
+        .map(|&f| f.to_owned().into())
+        .ok_or(MacroError::Keyword { kw: kw.into() })
+}
+
+#[derive(Error, Debug)]
+pub enum MacroError {
+    #[error("no matching value found for keyword, {kw}")]
+    Keyword { kw: String },
+    #[error("expected {expected} params, received {received} instead")]
+    InvalidParameters { expected: usize, received: usize },
+    #[error("macro: {name}, does not exist")]
+    UndefinedMacro { name: String },
+    #[error("{0}")]
+    IoError(#[from] FileError),
 }
diff --git a/crates/org-exporter/src/types.rs b/crates/org-exporter/src/types.rs
index fc041d2..e9cf4c4 100644
--- a/crates/org-exporter/src/types.rs
+++ b/crates/org-exporter/src/types.rs
@@ -1,7 +1,11 @@
 use core::fmt;
-use std::path::PathBuf;
-
 use org_parser::{NodeID, Parser};
+use std::{ops::Range, path::PathBuf};
+use thiserror::Error;
+
+pub(crate) type Result<T> = core::result::Result<T, ExportError>;
+
+use crate::{include::IncludeError, org_macros::MacroError};
 
 #[derive(Debug, Clone, Default)]
 pub struct ConfigOptions {
@@ -9,6 +13,33 @@ pub struct ConfigOptions {
     file_path: Option<PathBuf>,
 }
 
+#[derive(Debug, Error)]
+pub enum ExportError {
+    #[error("{0}-{1}: {source}", span.start, span.end)]
+    LogicError {
+        span: Range<usize>,
+        source: LogicErrorKind,
+    },
+    #[error("{0}")]
+    WriteError(#[from] fmt::Error),
+}
+
+#[derive(Debug, Error)]
+pub enum LogicErrorKind {
+    #[error("{0}")]
+    Include(#[from] IncludeError),
+    #[error("{0}")]
+    Macro(#[from] MacroError),
+}
+
+#[derive(Debug, Error)]
+#[error("{context} {path}: {source}")]
+pub struct FileError {
+    pub context: String,
+    pub path: PathBuf,
+    pub source: std::io::Error,
+}
+
 impl ConfigOptions {
     pub fn new(file_path: Option<PathBuf>) -> Self {
         Self { file_path }
@@ -23,18 +54,21 @@ impl ConfigOptions {
 /// Exporting backends must implement this trait.
 pub trait Exporter<'buf> {
     /// Writes the AST generated from the input into a `String`.
-    fn export(input: &str, conf: ConfigOptions) -> core::result::Result<String, fmt::Error>;
+    fn export(input: &str, conf: ConfigOptions) -> Result<String>;
     /// Writes the AST generated from the input into a buffer that implements `Write`.
     fn export_buf<'inp, T: fmt::Write>(
         input: &'inp str,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> fmt::Result;
+    ) -> Result<()>;
     fn export_tree<T: fmt::Write>(
         parsed: &Parser,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> fmt::Result;
+    ) -> Result<()>;
+
+    // fn errors(&self) -> Vec<ExportError>;
+    // fn warnings(&self);
 }
 
 /// Private interface for Exporter types.
@@ -47,11 +81,11 @@ pub(crate) trait ExporterInner<'buf> {
         input: &'inp str,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> fmt::Result;
+    ) -> Result<()>;
     /// Primary exporting routine.
     ///
     /// This method is called recursively until every `Node` in the tree is exhausted.
-    fn export_rec(&mut self, node_id: &NodeID, parser: &Parser) -> fmt::Result;
+    fn export_rec(&mut self, node_id: &NodeID, parser: &Parser) -> Result<()>;
     /// The canonical name of the exporting backend
     /// REVIEW: make public?
     fn backend_name() -> &'static str;

From 285dbd2753e632082ac8d9e4639e578360adec92 Mon Sep 17 00:00:00 2001
From: Laith <laithbahodi@gmail.com>
Date: Sun, 22 Sep 2024 02:14:25 -0400
Subject: [PATCH 10/14] feat(org-wasm): convey errors on site

no longer unwraps, instead passes the error on screen

also clean them up a bit for presentation
---
 crates/org-exporter/src/include.rs    |  4 ++--
 crates/org-exporter/src/org_macros.rs |  8 ++++----
 crates/org-exporter/src/types.rs      |  4 ++--
 crates/org-wasm/main.js               |  2 +-
 crates/org-wasm/src/lib.rs            | 13 +++++++++----
 5 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/crates/org-exporter/src/include.rs b/crates/org-exporter/src/include.rs
index 7e88189..2922b0b 100644
--- a/crates/org-exporter/src/include.rs
+++ b/crates/org-exporter/src/include.rs
@@ -197,7 +197,7 @@ pub(crate) fn include_handle<'a>(
         temp_path
             .canonicalize()
             .map_err(|e| FileError {
-                context: "failed to locate file".into(),
+                context: "".into(),
                 path: temp_path,
                 source: e,
             })?
@@ -206,7 +206,7 @@ pub(crate) fn include_handle<'a>(
         ret.file.into()
     };
     let mut out_str = read_to_string(&target_path).map_err(|e| FileError {
-        context: "failed to read file".into(),
+        context: "".into(),
         path: target_path.into(),
         source: e,
     })?;
diff --git a/crates/org-exporter/src/org_macros.rs b/crates/org-exporter/src/org_macros.rs
index 78e511b..6b7fd49 100644
--- a/crates/org-exporter/src/org_macros.rs
+++ b/crates/org-exporter/src/org_macros.rs
@@ -113,7 +113,7 @@ pub(crate) fn keyword_file<'a>(
         temp_path
             .canonicalize()
             .map_err(|e| FileError {
-                context: "failed to locate file".into(),
+                context: "Error during macro invocation of kw-file. ".into(),
                 path: temp_path,
                 source: e,
             })?
@@ -123,7 +123,7 @@ pub(crate) fn keyword_file<'a>(
     };
 
     let out_str = read_to_string(&target_path).map_err(|e| FileError {
-        context: "failed to read file".into(),
+        context: "Error during macro invocation of kw-file. ".into(),
         path: target_path.into(),
         source: e,
     })?;
@@ -137,11 +137,11 @@ pub(crate) fn keyword_file<'a>(
 
 #[derive(Error, Debug)]
 pub enum MacroError {
-    #[error("no matching value found for keyword, {kw}")]
+    #[error("no matching value found for keyword `{kw}`")]
     Keyword { kw: String },
     #[error("expected {expected} params, received {received} instead")]
     InvalidParameters { expected: usize, received: usize },
-    #[error("macro: {name}, does not exist")]
+    #[error("call to invalid macro `{name}`")]
     UndefinedMacro { name: String },
     #[error("{0}")]
     IoError(#[from] FileError),
diff --git a/crates/org-exporter/src/types.rs b/crates/org-exporter/src/types.rs
index e9cf4c4..bdcaf4c 100644
--- a/crates/org-exporter/src/types.rs
+++ b/crates/org-exporter/src/types.rs
@@ -1,6 +1,6 @@
 use core::fmt;
 use org_parser::{NodeID, Parser};
-use std::{ops::Range, path::PathBuf};
+use std::{fmt::Display, ops::Range, path::PathBuf};
 use thiserror::Error;
 
 pub(crate) type Result<T> = core::result::Result<T, ExportError>;
@@ -33,7 +33,7 @@ pub enum LogicErrorKind {
 }
 
 #[derive(Debug, Error)]
-#[error("{context} {path}: {source}")]
+#[error("{context}`{path}`: {source}")]
 pub struct FileError {
     pub context: String,
     pub path: PathBuf,
diff --git a/crates/org-wasm/main.js b/crates/org-wasm/main.js
index baaf509..e0dd57a 100644
--- a/crates/org-wasm/main.js
+++ b/crates/org-wasm/main.js
@@ -200,7 +200,7 @@ function toggleView(name, button_name) {
 }
 
 function reparse() {
-  const result = parse_func(editor.state.doc.toString().concat("\n"));
+  const result = parse_func(editor.state.doc.toString());
   // actually changing srcdoc causes extreme white flashing.
   // updating the iframe like this is much better
   if (currElem === view_dict["rendered"]) {
diff --git a/crates/org-wasm/src/lib.rs b/crates/org-wasm/src/lib.rs
index eaf0be1..ebb83c9 100644
--- a/crates/org-wasm/src/lib.rs
+++ b/crates/org-wasm/src/lib.rs
@@ -43,15 +43,20 @@ impl WasmExport {
     #[wasm_bindgen]
     pub fn to_org(&mut self, s: &str) -> JsValue {
         self.string_buf.clear();
-        Org::export_buf(s, &mut self.string_buf, ConfigOptions::default()).unwrap();
-        JsValue::from_str(&self.string_buf)
+        match Org::export_buf(s, &mut self.string_buf, ConfigOptions::default()) {
+            Ok(_) => JsValue::from_str(&self.string_buf),
+            Err(e) => JsValue::from_str(&e.to_string()),
+        }
     }
 
     #[wasm_bindgen]
     pub fn to_html(&mut self, s: &str) -> JsValue {
         self.string_buf.clear();
-        Html::export_buf(s, &mut self.string_buf, ConfigOptions::default()).unwrap();
-        JsValue::from_str(&self.string_buf)
+
+        match Html::export_buf(s, &mut self.string_buf, ConfigOptions::default()) {
+            Ok(_) => JsValue::from_str(&self.string_buf),
+            Err(e) => JsValue::from_str(&e.to_string()),
+        }
     }
 }
 

From 2ae790fd52477fa36efd2b69f78478c74bf3a311 Mon Sep 17 00:00:00 2001
From: Laith <laithbahodi@gmail.com>
Date: Sun, 22 Sep 2024 02:15:51 -0400
Subject: [PATCH 11/14] feat: improve handling for comments & eof

go right up to the end
---
 crates/org-parser/src/element/comment.rs | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/crates/org-parser/src/element/comment.rs b/crates/org-parser/src/element/comment.rs
index 3c0fc7c..4407e23 100644
--- a/crates/org-parser/src/element/comment.rs
+++ b/crates/org-parser/src/element/comment.rs
@@ -1,5 +1,7 @@
+use crate::constants::NEWLINE;
 use crate::node_pool::NodeID;
 use crate::types::{Cursor, ParseOpts, Parseable, Parser, Result};
+use crate::utils::bytes_to_str;
 
 #[derive(Debug, Clone, Copy)]
 pub struct Comment<'a>(pub &'a str);
@@ -13,12 +15,12 @@ impl<'a> Parseable<'a> for Comment<'a> {
     ) -> Result<NodeID> {
         let start = cursor.index;
         if cursor.peek(1)?.is_ascii_whitespace() {
-            // skip past "# "
-            cursor.advance(2);
-            let content = cursor.fn_until(|chr: u8| chr == b'\n')?;
+            let prev = cursor.index;
+            cursor.adv_till_byte(NEWLINE);
+            let val = bytes_to_str(&cursor.byte_arr[prev..cursor.index]);
             // TODO: use an fn_until_inclusive to not have to add 1 to the end
             // (we want to eat the ending nl too)
-            Ok(parser.alloc(Self(content.obj), start, content.end + 1, parent))
+            Ok(parser.alloc(Self(val), start, cursor.index + 1, parent))
         } else {
             Err(crate::types::MatchError::InvalidLogic)
         }
@@ -40,6 +42,16 @@ mod tests {
         assert_eq!(l.0, "this is a comment")
     }
 
+    #[test]
+    fn comment_eof() {
+        let inp = "# this is a comment";
+
+        let parsed = parse_org(inp);
+
+        let l = expr_in_pool!(parsed, Comment).unwrap();
+        assert_eq!(l.0, "this is a comment")
+    }
+
     #[test]
     fn basic_comment_not() {
         let inp = "#this is not a comment";

From ffe730bdcf680d42a26d7365fe215ea4f5a93998 Mon Sep 17 00:00:00 2001
From: Laith <laithbahodi@gmail.com>
Date: Sun, 22 Sep 2024 20:04:22 -0400
Subject: [PATCH 12/14] feat: report all errors found while exporting

no longer stops after just one. also update org-wasm/org-cli to report
these to the user.

had to update the tests since there isnt a clean way to call =?= on a
vec of items, so they all return nothing (and unwrap) instead of
Result<()>. probably cleaner this way anyways
---
 crates/org-cli/src/cli.rs                |   2 +-
 crates/org-cli/src/main.rs               |   9 +-
 crates/org-exporter/src/html.rs          | 209 ++++++++++++-----------
 crates/org-exporter/src/include.rs       |   2 +-
 crates/org-exporter/src/org.rs           | 200 +++++++++++-----------
 crates/org-exporter/src/types.rs         |  11 +-
 crates/org-exporter/src/utils.rs         |   2 +-
 crates/org-parser/src/element/comment.rs |   2 +-
 crates/org-parser/src/element/keyword.rs |  11 +-
 crates/org-wasm/src/lib.rs               |  45 ++++-
 10 files changed, 271 insertions(+), 222 deletions(-)

diff --git a/crates/org-cli/src/cli.rs b/crates/org-cli/src/cli.rs
index ec61813..47ef818 100644
--- a/crates/org-cli/src/cli.rs
+++ b/crates/org-cli/src/cli.rs
@@ -51,7 +51,7 @@ impl Backend {
         parsed: &org_parser::Parser,
         buf: &mut String,
         conf: ConfigOptions
-    ) -> Result<(), org_exporter::ExportError> {
+    ) -> Result<(), Vec<org_exporter::ExportError>> {
         match self {
             Backend::Html => org_exporter::Html::export_tree(parsed, buf, conf),
             Backend::Org => org_exporter::Org::export_tree(parsed, buf, conf),
diff --git a/crates/org-cli/src/main.rs b/crates/org-cli/src/main.rs
index df62ca2..d318a52 100644
--- a/crates/org-cli/src/main.rs
+++ b/crates/org-cli/src/main.rs
@@ -161,7 +161,14 @@ fn run() -> anyhow::Result<()> {
             }
 
             let conf = ConfigOptions::new(Some(file_path.to_path_buf()));
-            backend.export(&parser_output, &mut exported_content, conf)?;
+            if let Err(err_vec) = backend.export(&parser_output, &mut exported_content, conf) {
+                let mut build_str = String::new();
+                for e in err_vec {
+                    build_str.push_str(&e.to_string());
+                    build_str.push_str("\n");
+                }
+                Err(CliError::new().with_cause(&build_str))?
+            }
 
             // handle a template (if needed)
             if let Some(template_path) = parser_output.keywords.get("template_path") {
diff --git a/crates/org-exporter/src/html.rs b/crates/org-exporter/src/html.rs
index 43feefa..11a85cb 100644
--- a/crates/org-exporter/src/html.rs
+++ b/crates/org-exporter/src/html.rs
@@ -70,6 +70,7 @@ pub struct Html<'buf> {
     footnotes: Vec<NodeID>,
     footnote_ids: HashMap<NodeID, usize>,
     conf: ConfigOptions,
+    errors: Vec<ExportError>,
 }
 
 /// Wrapper around strings that need to be properly HTML escaped.
@@ -114,7 +115,7 @@ impl<'a, S: AsRef<str>> fmt::Display for HtmlEscape<S> {
 }
 
 impl<'buf> Exporter<'buf> for Html<'buf> {
-    fn export(input: &str, conf: ConfigOptions) -> Result<String> {
+    fn export(input: &str, conf: ConfigOptions) -> core::result::Result<String, Vec<ExportError>> {
         let mut buf = String::new();
         Html::export_buf(input, &mut buf, conf)?;
         Ok(buf)
@@ -124,7 +125,7 @@ impl<'buf> Exporter<'buf> for Html<'buf> {
         input: &'inp str,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> Result<()> {
+    ) -> core::result::Result<(), Vec<ExportError>> {
         let parsed: Parser<'_> = parse_org(input);
         Html::export_tree(&parsed, buf, conf)
     }
@@ -133,35 +134,51 @@ impl<'buf> Exporter<'buf> for Html<'buf> {
         parsed: &Parser,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> Result<()> {
+    ) -> core::result::Result<(), Vec<ExportError>> {
         let mut obj = Html {
             buf,
             nox: HashSet::new(),
             footnotes: Vec::new(),
             footnote_ids: HashMap::new(),
             conf,
+            errors: Vec::new(),
         };
 
         if let Ok(opts) = Options::handle_opts(parsed) {
             if let Ok(tocs) = process_toc(parsed, &opts) {
-                write!(
-                    obj,
-                    r#"<nav id="table-of-contents" role="doc-toc">
+                handle_toc(parsed, &mut obj, &tocs);
+            }
+        }
+        obj.export_rec(&parsed.pool.root_id(), &parsed);
+        obj.exp_footnotes(&parsed);
+
+        if obj.errors().is_empty() {
+            Ok(())
+        } else {
+            Err(obj.errors)
+        }
+    }
+}
+
+fn handle_toc<'a, T: fmt::Write + ExporterInner<'a>>(
+    parsed: &Parser,
+    writer: &mut T,
+    tocs: &Vec<TocItem>,
+) -> Result<()> {
+    write!(
+        writer,
+        r#"<nav id="table-of-contents" role="doc-toc">
 <h2>Table Of Contents</h2>
 <div id="text-table-of-contents" role="doc-toc">
 "#
-                )?;
-                write!(obj, "<ul>")?;
-                for toc in tocs {
-                    toc_rec(&parsed, &mut obj, &toc, 1)?;
-                }
-                write!(obj, "</ul>")?;
-                write!(obj, r#"</div></nav>"#)?;
-            }
-        }
-        obj.export_rec(&parsed.pool.root_id(), &parsed)?;
-        obj.exp_footnotes(&parsed)
+    )?;
+    write!(writer, "<ul>")?;
+    for toc in tocs {
+        toc_rec(&parsed, writer, toc, 1)?;
     }
+    write!(writer, "</ul>")?;
+    write!(writer, r#"</div></nav>"#)?;
+    Ok(())
 }
 
 fn toc_rec<'a, T: fmt::Write + ExporterInner<'a>>(
@@ -199,7 +216,7 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
         input: &'inp str,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> Result<()> {
+    ) -> core::result::Result<(), Vec<ExportError>> {
         let parsed = parse_macro_call(input);
         let mut obj = Html {
             buf,
@@ -207,9 +224,15 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
             footnotes: Vec::new(),
             footnote_ids: HashMap::new(),
             conf,
+            errors: Vec::new(),
         };
 
-        obj.export_rec(&parsed.pool.root_id(), &parsed)
+        obj.export_rec(&parsed.pool.root_id(), &parsed);
+        if obj.errors().is_empty() {
+            Ok(())
+        } else {
+            Err(obj.errors)
+        }
     }
 
     fn export_rec(&mut self, node_id: &NodeID, parser: &Parser) -> Result<()> {
@@ -540,10 +563,19 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                     write!(self, ">")?;
 
                     // TODO have vec to store errors instead of blowing up
-                    include_handle(inner.val, self).map_err(|e| ExportError::LogicError {
-                        span: node.start..node.end,
-                        source: LogicErrorKind::Include(e),
-                    })?;
+
+                    if let Err(e) = include_handle(inner.val, self) {
+                        self.errors().push(ExportError::LogicError {
+                            span: node.start..node.end,
+                            source: LogicErrorKind::Include(e),
+                        });
+                        return Ok(());
+                    }
+
+                    //     .map_err(|e| ExportError::LogicError {
+                    //     span: node.start..node.end,
+                    //     source: LogicErrorKind::Include(e),
+                    // })?;
                     write!(self, "</div>")?;
                 }
             }
@@ -725,17 +757,25 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                 )?;
             }
             Expr::Macro(macro_call) => {
-                let macro_contents =
-                    macro_handle(parser, macro_call, self.config_opts()).map_err(|e| {
-                        ExportError::LogicError {
+                let macro_contents = match macro_handle(parser, macro_call, self.config_opts()) {
+                    Ok(contents) => contents,
+                    Err(e) => {
+                        self.errors().push(ExportError::LogicError {
                             span: node.start..node.end,
                             source: LogicErrorKind::Macro(e),
-                        }
-                    })?;
+                        });
+                        return Ok(());
+                    }
+                };
 
                 match macro_contents {
                     Cow::Owned(p) => {
-                        Html::export_macro_buf(&p, self, self.config_opts().clone())?;
+                        if let Err(mut err_vec) =
+                            Html::export_macro_buf(&p, self, self.config_opts().clone())
+                        {
+                            self.errors().append(&mut err_vec);
+                            return Ok(());
+                        }
                     }
                     Cow::Borrowed(r) => {
                         write!(self, "{}", HtmlEscape(r))?;
@@ -822,6 +862,9 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
     fn config_opts(&self) -> &ConfigOptions {
         &self.conf
     }
+    fn errors(&mut self) -> &mut Vec<ExportError> {
+        &mut self.errors
+    }
 }
 
 // Writers for generic attributes
@@ -938,49 +981,46 @@ mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
 
-    fn html_export(input: &str) -> Result<String> {
-        Html::export(input, ConfigOptions::default())
+    fn html_export(input: &str) -> String {
+        Html::export(input, ConfigOptions::default()).unwrap()
     }
     #[test]
-    fn combined_macros() -> Result<()> {
+    fn combined_macros() {
         let a = html_export(
             r"#+macro: poem hiii $1 $2 text
 {{{poem(cool,three)}}}
 ",
-        )?;
+        );
 
         assert_eq!(
             a,
             r"<p>hiii cool three text</p>
 "
         );
-
-        Ok(())
     }
 
     #[test]
-    fn keyword_macro() -> Result<()> {
+    fn keyword_macro() {
         let a = html_export(
             r"
      #+title: hiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
 {{{keyword(title)}}}
 ",
-        )?;
+        );
 
         assert_eq!(
             a,
             r"<p>hiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii</p>
 ",
         );
-        Ok(())
     }
 
     #[test]
-    fn line_break() -> Result<()> {
+    fn line_break() {
         let a = html_export(
             r" abc\\
 ",
-        )?;
+        );
 
         assert_eq!(
             a,
@@ -993,32 +1033,31 @@ mod tests {
         let n = html_export(
             r" abc\\   q
 ",
-        )?;
+        );
 
         assert_eq!(
             n,
             r"<p>abc\\   q</p>
 ",
         );
-        Ok(())
     }
 
     #[test]
-    fn horizontal_rule() -> Result<()> {
+    fn horizontal_rule() {
         let a = html_export(
             r"-----
 ",
-        )?;
+        );
 
         let b = html_export(
             r"                -----
 ",
-        )?;
+        );
 
         let c = html_export(
             r"      -------------------------
 ",
-        )?;
+        );
 
         assert_eq!(a, b);
         assert_eq!(b, c);
@@ -1027,19 +1066,17 @@ mod tests {
         let nb = html_export(
             r"                ----
 ",
-        )?;
+        );
 
         assert_eq!(
             nb,
             r"<p>----</p>
 ",
         );
-
-        Ok(())
     }
 
     #[test]
-    fn correct_cache() -> Result<()> {
+    fn correct_cache() {
         let a = html_export(
             r"
 - one
@@ -1049,35 +1086,31 @@ mod tests {
 abc &+ 10\\
 \end{align}
 ",
-        )?;
+        );
         println!("{a}");
-
-        Ok(())
     }
 
     #[test]
-    fn html_unicode() -> Result<()> {
+    fn html_unicode() {
         let a = html_export(
             r"a é😳
 ",
-        )?;
+        );
 
         assert_eq!(
             a,
             r"<p>a é😳</p>
 "
         );
-
-        Ok(())
     }
 
     #[test]
-    fn list_counter_set() -> Result<()> {
+    fn list_counter_set() {
         let a = html_export(
             r"
 1. [@4] wordsss??
 ",
-        )?;
+        );
 
         assert_eq!(
             a,
@@ -1087,15 +1120,14 @@ abc &+ 10\\
 </ol>
 "#,
         );
-        Ok(())
     }
     #[test]
-    fn anon_footnote() -> Result<()> {
+    fn anon_footnote() {
         let a = html_export(
             r"
 hi [fn:next:coolio] yeah [fn:next]
 ",
-        )?;
+        );
         // just codifying what the output is here, not supposed to be set in stone
         assert_eq!(
             a,
@@ -1123,11 +1155,10 @@ coolio</div>
   </div>
 </div>"##
         );
-        Ok(())
     }
 
     #[test]
-    fn footnote_heading() -> Result<()> {
+    fn footnote_heading() {
         let a = html_export(
             r"
 hello [fn:1]
@@ -1136,7 +1167,7 @@ hello [fn:1]
 
 [fn:1] world
 ",
-        )?;
+        );
 
         // just codifying what the output is here, not supposed to be set in stone
         assert_eq!(
@@ -1164,11 +1195,10 @@ hello [fn:1]
   </div>
 </div>"##
         );
-        Ok(())
     }
 
     #[test]
-    fn footnote_order() -> Result<()> {
+    fn footnote_order() {
         // tests dupes too
         let a = html_export(
             r#"
@@ -1185,7 +1215,7 @@ novel [fn:next:coolio]
 [fn:coolnote] words babby
 
 "#,
-        )?;
+        );
 
         // REVIEW; investigate different nodeids with export_buf and export
         // had to change 1.7 to 1.8 to pass the test
@@ -1245,11 +1275,10 @@ coolio</div>
   </div>
 </div>"##
         );
-        Ok(())
     }
 
     #[test]
-    fn esoteric_footnotes() -> Result<()> {
+    fn esoteric_footnotes() {
         let a = html_export(
             r"
 And anonymous ones [fn::mysterious]
@@ -1258,7 +1287,7 @@ what [fn::]
 
 bad [fn:]
 ",
-        )?;
+        );
 
         assert_eq!(
             a,
@@ -1294,47 +1323,41 @@ mysterious</div>
   </div>
 </div>"##
         );
-
-        Ok(())
     }
 
     #[test]
-    fn file_link() -> Result<()> {
-        let a = html_export(r"[[file:html.org][hi]]")?;
+    fn file_link() {
+        let a = html_export(r"[[file:html.org][hi]]");
 
         assert_eq!(
             a,
             r#"<p><a href="html.org">hi</a></p>
 "#
         );
-
-        Ok(())
     }
 
     #[test]
-    fn file_link_image() -> Result<()> {
+    fn file_link_image() {
         let a = html_export(
             r"
 [[file:bmc.jpg]]
 ",
-        )?;
+        );
         assert_eq!(
             a,
             r#"<figure>
 <img src="bmc.jpg" alt="bmc.jpg">
 </figure>"#
         );
-
-        Ok(())
     }
 
     #[test]
-    fn basic_link_image() -> Result<()> {
+    fn basic_link_image() {
         let a = html_export(
             r"
 [[https://upload.wikimedia.org/wikipedia/commons/a/a6/Org-mode-unicorn.svg]]
 ",
-        )?;
+        );
 
         assert_eq!(
             a,
@@ -1342,26 +1365,22 @@ mysterious</div>
 <img src="https://upload.wikimedia.org/wikipedia/commons/a/a6/Org-mode-unicorn.svg" alt="Org-mode-unicorn.svg">
 </figure>"#
         );
-
-        Ok(())
     }
 
     #[test]
-    fn unspecified_link() -> Result<()> {
-        let a = html_export(r"[[./hello]]")?;
+    fn unspecified_link() {
+        let a = html_export(r"[[./hello]]");
 
         assert_eq!(
             a,
             r##"<p><a href="./hello">./hello</a></p>
 "##
         );
-
-        Ok(())
     }
 
     #[test]
-    fn checkbox() -> Result<()> {
-        let a = html_export("- [X]\n")?;
+    fn checkbox() {
+        let a = html_export("- [X]\n");
 
         assert_eq!(
             a,
@@ -1371,7 +1390,7 @@ mysterious</div>
 "#
         );
 
-        let b = html_export("- [ ]\n")?;
+        let b = html_export("- [ ]\n");
 
         assert_eq!(
             b,
@@ -1381,7 +1400,7 @@ mysterious</div>
 "#
         );
 
-        let c = html_export("- [-]\n")?;
+        let c = html_export("- [-]\n");
 
         assert_eq!(
             c,
@@ -1390,8 +1409,6 @@ mysterious</div>
 </ul>
 "#
         );
-
-        Ok(())
     }
 
     #[test]
@@ -1410,7 +1427,7 @@ content
 here
 "#;
         assert_eq!(
-            html_export(a).unwrap(),
+            html_export(a),
             "<h1 id=\"yeah\">yeah</h1>\n<p>hello</p>\n<p>hi</p>\n<p>content</p>\n<p>here</p>\n"
         );
     }
diff --git a/crates/org-exporter/src/include.rs b/crates/org-exporter/src/include.rs
index 2922b0b..a4dcccf 100644
--- a/crates/org-exporter/src/include.rs
+++ b/crates/org-exporter/src/include.rs
@@ -300,6 +300,6 @@ pub enum IncludeError {
     NotStringMinlevel(String),
     #[error("{0}")]
     IoError(#[from] FileError),
-    #[error("{0}")]
+    #[error("failure while handling file {0}")]
     FileExport(#[from] Box<ExportError>),
 }
diff --git a/crates/org-exporter/src/org.rs b/crates/org-exporter/src/org.rs
index e83cd7a..285861f 100644
--- a/crates/org-exporter/src/org.rs
+++ b/crates/org-exporter/src/org.rs
@@ -23,11 +23,11 @@ pub struct Org<'buf> {
     indentation_level: u8,
     on_newline: bool,
     conf: ConfigOptions,
-    // errors: Vec<ExportError>,
+    errors: Vec<ExportError>,
 }
 
 impl<'buf> Exporter<'buf> for Org<'buf> {
-    fn export(input: &str, conf: ConfigOptions) -> Result<String> {
+    fn export(input: &str, conf: ConfigOptions) -> core::result::Result<String, Vec<ExportError>> {
         let mut buf = String::new();
         Org::export_buf(input, &mut buf, conf)?;
         Ok(buf)
@@ -37,7 +37,7 @@ impl<'buf> Exporter<'buf> for Org<'buf> {
         input: &'inp str,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> Result<()> {
+    ) -> core::result::Result<(), Vec<ExportError>> {
         let parsed = parse_org(input);
         Org::export_tree(&parsed, buf, conf)
     }
@@ -46,15 +46,22 @@ impl<'buf> Exporter<'buf> for Org<'buf> {
         parsed: &Parser,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> Result<()> {
+    ) -> core::result::Result<(), Vec<ExportError>> {
         let mut obj = Org {
             buf,
             indentation_level: 0,
             on_newline: false,
             conf,
+            errors: Vec::new(),
         };
 
-        obj.export_rec(&parsed.pool.root_id(), &parsed)
+        obj.export_rec(&parsed.pool.root_id(), &parsed);
+
+        if obj.errors().is_empty() {
+            Ok(())
+        } else {
+            Err(obj.errors)
+        }
     }
 }
 
@@ -63,7 +70,7 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
         input: &'inp str,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> Result<()> {
+    ) -> core::result::Result<(), Vec<ExportError>> {
         let parsed = org_parser::parse_macro_call(input);
 
         let mut obj = Org {
@@ -71,9 +78,15 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
             indentation_level: 0,
             on_newline: false,
             conf: ConfigOptions::default(),
+            errors: Vec::new(),
         };
 
-        obj.export_rec(&parsed.pool.root_id(), &parsed)
+        obj.export_rec(&parsed.pool.root_id(), &parsed);
+        if obj.errors().is_empty() {
+            Ok(())
+        } else {
+            Err(obj.errors)
+        }
     }
 
     fn export_rec(&mut self, node_id: &NodeID, parser: &Parser) -> Result<()> {
@@ -341,10 +354,13 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
             }
             Expr::Keyword(inner) => {
                 if inner.key.to_ascii_lowercase() == "include" {
-                    include_handle(inner.val, self).map_err(|e| ExportError::LogicError {
-                        span: node.start..node.end,
-                        source: LogicErrorKind::Include(e),
-                    })?;
+                    if let Err(e) = include_handle(inner.val, self) {
+                        self.errors().push(ExportError::LogicError {
+                            span: node.start..node.end,
+                            source: LogicErrorKind::Include(e),
+                        });
+                        return Ok(());
+                    }
                 }
             }
             Expr::LatexEnv(inner) => {
@@ -439,11 +455,13 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                                 TableRow::Standard(stans) => {
                                     for id in stans {
                                         let mut cell_buf = String::new();
+                                        // FIXME/HACK: this is weird
                                         let mut new_obj = Org {
                                             buf: &mut cell_buf,
                                             indentation_level: self.indentation_level,
                                             on_newline: self.on_newline,
                                             conf: self.conf.clone(),
+                                            errors: Vec::new(),
                                         };
                                         new_obj.export_rec(id, parser)?;
                                         row_vec.push(cell_buf);
@@ -558,17 +576,25 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                 write!(self, "<<{}>>", inner.0)?;
             }
             Expr::Macro(macro_call) => {
-                let macro_contents =
-                    macro_handle(parser, macro_call, self.config_opts()).map_err(|e| {
-                        ExportError::LogicError {
+                let macro_contents = match macro_handle(parser, macro_call, self.config_opts()) {
+                    Ok(contents) => contents,
+                    Err(e) => {
+                        self.errors().push(ExportError::LogicError {
                             span: node.start..node.end,
                             source: LogicErrorKind::Macro(e),
-                        }
-                    })?;
+                        });
+                        return Ok(());
+                    }
+                };
 
                 match macro_contents {
                     Cow::Owned(p) => {
-                        Org::export_macro_buf(&p, self, self.config_opts().clone())?;
+                        if let Err(mut err_vec) =
+                            Org::export_macro_buf(&p, self, self.config_opts().clone())
+                        {
+                            self.errors().append(&mut err_vec);
+                            return Ok(());
+                        }
                     }
                     Cow::Borrowed(r) => {
                         write!(self, "{r}")?;
@@ -621,6 +647,10 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
     fn config_opts(&self) -> &ConfigOptions {
         &self.conf
     }
+
+    fn errors(&mut self) -> &mut Vec<ExportError> {
+        &mut self.errors
+    }
 }
 
 impl<'buf> fmt::Write for Org<'buf> {
@@ -651,22 +681,21 @@ impl<'buf> fmt::Write for Org<'buf> {
 mod tests {
     use super::*;
 
-    use crate::types::Result;
     use pretty_assertions::assert_eq;
 
-    fn org_export(input: &str) -> Result<String> {
-        Org::export(input, ConfigOptions::default())
+    fn org_export(input: &str) -> String {
+        Org::export(input, ConfigOptions::default()).unwrap()
     }
 
     #[test]
-    fn basic_org_export() -> Result<()> {
+    fn basic_org_export()  {
         let out_str = org_export(
             r"** one two
 three
 *four*
 
 ",
-        )?;
+        );
 
         assert_eq!(
             out_str,
@@ -675,11 +704,10 @@ three *four*
 
 "
         );
-        Ok(())
     }
 
     #[test]
-    fn fancy_list_export() -> Result<()> {
+    fn fancy_list_export()  {
         let a = org_export(
             r"
     + one two three
@@ -690,7 +718,7 @@ three *four*
     + four
     +five
 ",
-        )?;
+        );
 
         assert_eq!(
             a,
@@ -704,19 +732,16 @@ four five six
 +five
 "
         );
-
-        Ok(())
     }
 
     #[test]
-    fn test_link_export() -> Result<()> {
-        let out = org_export("[[https://swag.org][meowww]]")?;
+    fn test_link_export()  {
+        let out = org_export("[[https://swag.org][meowww]]");
         println!("{out}");
-        Ok(())
     }
 
     #[test]
-    fn test_beeg() -> Result<()> {
+    fn test_beeg()  {
         let out = org_export(
             r"* DONE [#0] *one* two /three/ /four*       :one:two:three:four:
 more content here this is a pargraph
@@ -849,21 +874,20 @@ more content here this is a pargraph
 more content here this is a pargraph
 more content here this is a pargraph
 ",
-        )?;
+        );
 
         println!("{out}");
-        Ok(())
     }
 
     #[test]
-    fn less() -> Result<()> {
+    fn less()  {
         let out = org_export(
             r"* [#1] abc :c:
 ** [#1] descendant headline :a:b:
 *** [#2] inherit the tags
 ** [#3] different level
 ",
-        )?;
+        );
 
         assert_eq!(
             out,
@@ -874,11 +898,10 @@ more content here this is a pargraph
 "
         );
         println!("{out}");
-        Ok(())
     }
 
     #[test]
-    fn list_export() -> Result<()> {
+    fn list_export()  {
         let a = org_export(
             r"
 - one
@@ -889,7 +912,7 @@ more content here this is a pargraph
 - six
  - seven
 ",
-        )?;
+        );
 
         println!("{a}");
         assert_eq!(
@@ -904,12 +927,10 @@ more content here this is a pargraph
   - seven
 "
         );
-
-        Ok(())
     }
 
     #[test]
-    fn basic_list_export() -> Result<()> {
+    fn basic_list_export()  {
         let a = org_export(
             r"
 - one
@@ -921,7 +942,7 @@ more content here this is a pargraph
    - seven
 - eight
 ",
-        )?;
+        );
 
         println!("{a}");
         assert_eq!(
@@ -937,12 +958,10 @@ more content here this is a pargraph
 - eight
 "
         );
-
-        Ok(())
     }
 
     #[test]
-    fn list_words() -> Result<()> {
+    fn list_words()  {
         let a: String = org_export(
             r"
 1. item 1
@@ -956,7 +975,7 @@ more content here this is a pargraph
 2. [X] item 2
    - aome tag :: item 2.1
 ",
-        )?;
+        );
 
         println!("{a}");
 
@@ -977,12 +996,9 @@ more content here this is a pargraph
         //   - aome tag :: item 2.1
         // "
         //         );
-
-        Ok(())
     }
-
     #[test]
-    fn table_export() -> Result<()> {
+    fn table_export()  {
         let a = org_export(
             r"
 |one|two|
@@ -990,7 +1006,7 @@ more content here this is a pargraph
 |five|six|seven|
 |eight
 ",
-        )?;
+        );
 
         assert_eq!(
             a,
@@ -1001,12 +1017,10 @@ more content here this is a pargraph
 | eight |      |       |
 "
         );
-
-        Ok(())
     }
 
     #[test]
-    fn table_export_hrule() -> Result<()> {
+    fn table_export_hrule()  {
         let a = org_export(
             r"
 |one|two|
@@ -1018,7 +1032,7 @@ more content here this is a pargraph
 |swagg|long the
 |okay| _underline_| ~fake| _fake|
 ",
-        )?;
+        );
 
         println!("{a}");
         assert_eq!(
@@ -1035,12 +1049,10 @@ more content here this is a pargraph
 "
         );
         // println!("{a}");
-
-        Ok(())
     }
 
     #[test]
-    fn indented_table() -> Result<()> {
+    fn indented_table()  {
         let a = org_export(
             r"
 - zero
@@ -1054,7 +1066,7 @@ more content here this is a pargraph
     |okay| _underline_| ~fake| _fake|
 - ten
 ",
-        )?;
+        );
 
         assert_eq!(
             a,
@@ -1071,12 +1083,10 @@ more content here this is a pargraph
 - ten
 "
         );
-
-        Ok(())
     }
 
     #[test]
-    fn proper_list_indent() -> Result<()> {
+    fn proper_list_indent()  {
         let a = org_export(
             r"
 - one
@@ -1084,7 +1094,7 @@ more content here this is a pargraph
   - one
   - two
 ",
-        )?;
+        );
 
         assert_eq!(
             a,
@@ -1095,18 +1105,17 @@ more content here this is a pargraph
   - two
 "
         );
-        Ok(())
     }
 
     #[test]
-    fn heading_list_not() -> Result<()> {
+    fn heading_list_not()  {
         let a = org_export(
             r"
 - one
 - four
 * one
 ",
-        )?;
+        );
 
         // make sure * one is not interpreted as another element of the list,
         // instead as a separate heading (if it was another element, we'd have three -'s
@@ -1119,12 +1128,11 @@ more content here this is a pargraph
 * one
 "
         );
-        Ok(())
     }
 
     #[test]
-    fn proper_link() -> Result<()> {
-        let a = org_export(r"[[abc][one]]")?;
+    fn proper_link()  {
+        let a = org_export(r"[[abc][one]]");
 
         assert_eq!(
             a,
@@ -1132,23 +1140,21 @@ more content here this is a pargraph
 "
         );
 
-        Ok(())
     }
 
     #[test]
-    fn link_odd() -> Result<()> {
-        let a = org_export("[aayyyy][one]]")?;
+    fn link_odd()  {
+        let a = org_export("[aayyyy][one]]");
         assert_eq!(
             a,
             r"[aayyyy][one]]
 "
         );
-        Ok(())
     }
 
     #[test]
-    fn superscript() -> Result<()> {
-        let a = org_export(r"sample_text^{\gamma}")?;
+    fn superscript()  {
+        let a = org_export(r"sample_text^{\gamma}");
         assert_eq!(
             a,
             r"sample_{text}^{γ}
@@ -1158,7 +1164,7 @@ more content here this is a pargraph
         let b = org_export(
             r"sample_text^bunchoftextnowhite!,lkljas
  after",
-        )?;
+        );
 
         assert_eq!(
             b,
@@ -1166,20 +1172,18 @@ more content here this is a pargraph
 "
         );
 
-        let c = org_export(r"nowhere ^texto")?;
+        let c = org_export(r"nowhere ^texto");
 
         assert_eq!(
             c,
             r"nowhere ^texto
 "
         );
-
-        Ok(())
     }
 
     #[test]
-    fn subscript() -> Result<()> {
-        let a = org_export(r"sample_text_{\gamma}")?;
+    fn subscript()  {
+        let a = org_export(r"sample_text_{\gamma}");
         assert_eq!(
             a,
             r"sample_{text}_{γ}
@@ -1189,7 +1193,7 @@ more content here this is a pargraph
         let b = org_export(
             r"sample_{text}_bunchoftextnowhite!,lkljas
  after",
-        )?;
+        );
 
         assert_eq!(
             b,
@@ -1197,7 +1201,7 @@ more content here this is a pargraph
 "
         );
 
-        let c = org_export(r"nowhere _texto")?;
+        let c = org_export(r"nowhere _texto");
 
         assert_eq!(
             c,
@@ -1205,28 +1209,26 @@ more content here this is a pargraph
 "
         );
 
-        Ok(())
     }
 
     #[test]
-    fn plain_link() -> Result<()> {
-        let a = org_export("https://cool.com abc rest")?;
+    fn plain_link()  {
+        let a = org_export("https://cool.com abc rest");
 
         assert_eq!(
             a,
             "[[https://cool.com]] abc rest
 "
         );
-        Ok(())
     }
 
     #[test]
-    fn newline_literal_markup() -> Result<()> {
+    fn newline_literal_markup()  {
         let a = org_export(
             r"- test =if ~literal $interpreters \[handle newline \(properly {{{in(a lists
 - text that isn't disappearing!
 ",
-        )?;
+        );
 
         assert_eq!(
             a,
@@ -1234,12 +1236,10 @@ more content here this is a pargraph
 - text that isn't disappearing!
 "
         );
-
-        Ok(())
     }
 
     #[test]
-    fn lblock_plus_list() -> Result<()> {
+    fn lblock_plus_list()  {
         let a = org_export(
             r"
 -
@@ -1253,27 +1253,23 @@ meowwwwwwwwww
 
 -
 ",
-        )?;
+        );
         println!("{a}");
-
-        Ok(())
     }
 
     #[test]
-    fn markup_enclosed_in_bracks() -> Result<()> {
-        let a = org_export(r"[_enclosed text here_]")?;
+    fn markup_enclosed_in_bracks()  {
+        let a = org_export(r"[_enclosed text here_]");
 
         assert_eq!(
             a,
             "[_enclosed text here_]
 "
         );
-
-        Ok(())
     }
 
     #[test]
-    fn drawer() -> Result<()> {
+    fn drawer()  {
         let a = org_export(
             r"
 :NAME:
@@ -1289,7 +1285,7 @@ meowwwwwwwwww
 four
 :end:
 ",
-        )?;
+        );
         assert_eq!(
             a,
             r"
@@ -1308,7 +1304,5 @@ four
 
 "
         );
-
-        Ok(())
     }
 }
diff --git a/crates/org-exporter/src/types.rs b/crates/org-exporter/src/types.rs
index bdcaf4c..a291896 100644
--- a/crates/org-exporter/src/types.rs
+++ b/crates/org-exporter/src/types.rs
@@ -1,6 +1,6 @@
 use core::fmt;
 use org_parser::{NodeID, Parser};
-use std::{fmt::Display, ops::Range, path::PathBuf};
+use std::{ops::Range, path::PathBuf};
 use thiserror::Error;
 
 pub(crate) type Result<T> = core::result::Result<T, ExportError>;
@@ -54,18 +54,18 @@ impl ConfigOptions {
 /// Exporting backends must implement this trait.
 pub trait Exporter<'buf> {
     /// Writes the AST generated from the input into a `String`.
-    fn export(input: &str, conf: ConfigOptions) -> Result<String>;
+    fn export(input: &str, conf: ConfigOptions) -> core::result::Result<String, Vec<ExportError>>;
     /// Writes the AST generated from the input into a buffer that implements `Write`.
     fn export_buf<'inp, T: fmt::Write>(
         input: &'inp str,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> Result<()>;
+    ) -> core::result::Result<(), Vec<ExportError>>;
     fn export_tree<T: fmt::Write>(
         parsed: &Parser,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> Result<()>;
+    ) -> core::result::Result<(), Vec<ExportError>>;
 
     // fn errors(&self) -> Vec<ExportError>;
     // fn warnings(&self);
@@ -81,7 +81,7 @@ pub(crate) trait ExporterInner<'buf> {
         input: &'inp str,
         buf: &'buf mut T,
         conf: ConfigOptions,
-    ) -> Result<()>;
+    ) -> core::result::Result<(), Vec<ExportError>>;
     /// Primary exporting routine.
     ///
     /// This method is called recursively until every `Node` in the tree is exhausted.
@@ -90,4 +90,5 @@ pub(crate) trait ExporterInner<'buf> {
     /// REVIEW: make public?
     fn backend_name() -> &'static str;
     fn config_opts(&self) -> &ConfigOptions;
+    fn errors(&mut self) -> &mut Vec<ExportError>;
 }
diff --git a/crates/org-exporter/src/utils.rs b/crates/org-exporter/src/utils.rs
index db81009..7efdbb5 100644
--- a/crates/org-exporter/src/utils.rs
+++ b/crates/org-exporter/src/utils.rs
@@ -181,7 +181,7 @@ ul {
 
 "#,
             ConfigOptions::default(),
-        )?;
+        ).unwrap();
         println!("{a}");
         Ok(())
     }
diff --git a/crates/org-parser/src/element/comment.rs b/crates/org-parser/src/element/comment.rs
index 4407e23..2ae37df 100644
--- a/crates/org-parser/src/element/comment.rs
+++ b/crates/org-parser/src/element/comment.rs
@@ -17,7 +17,7 @@ impl<'a> Parseable<'a> for Comment<'a> {
         if cursor.peek(1)?.is_ascii_whitespace() {
             let prev = cursor.index;
             cursor.adv_till_byte(NEWLINE);
-            let val = bytes_to_str(&cursor.byte_arr[prev..cursor.index]);
+            let val = bytes_to_str(&cursor.byte_arr[(prev + 2)..cursor.index]);
             // TODO: use an fn_until_inclusive to not have to add 1 to the end
             // (we want to eat the ending nl too)
             Ok(parser.alloc(Self(val), start, cursor.index + 1, parent))
diff --git a/crates/org-parser/src/element/keyword.rs b/crates/org-parser/src/element/keyword.rs
index f8ca070..b42d803 100644
--- a/crates/org-parser/src/element/keyword.rs
+++ b/crates/org-parser/src/element/keyword.rs
@@ -163,19 +163,18 @@ impl<'a> Parseable<'a> for Keyword<'a> {
             _ => {}
         }
 
-        let prev = cursor.index;
-        cursor.adv_till_byte(NEWLINE);
         // not mentioned in the spec, but org-element trims
-        let val = bytes_to_str(&cursor.byte_arr[prev..cursor.index].trim_ascii());
+        let val = cursor.fn_until(|chr: u8| chr == b'\n')?;
+        let trimmed = val.obj.trim_ascii();
 
-        parser.keywords.insert(key_word.obj, val);
+        parser.keywords.insert(key_word.obj, trimmed);
         Ok(parser.alloc(
             Keyword {
                 key: key_word.obj,
-                val,
+                val: trimmed,
             },
             start,
-            cursor.index + 1,
+            val.end + 1,
             parent,
         ))
     }
diff --git a/crates/org-wasm/src/lib.rs b/crates/org-wasm/src/lib.rs
index ebb83c9..5685a04 100644
--- a/crates/org-wasm/src/lib.rs
+++ b/crates/org-wasm/src/lib.rs
@@ -1,4 +1,5 @@
 use org_exporter::ConfigOptions;
+use org_exporter::ExportError;
 use org_exporter::Exporter;
 use org_exporter::Html;
 use org_exporter::Org;
@@ -43,20 +44,50 @@ impl WasmExport {
     #[wasm_bindgen]
     pub fn to_org(&mut self, s: &str) -> JsValue {
         self.string_buf.clear();
-        match Org::export_buf(s, &mut self.string_buf, ConfigOptions::default()) {
-            Ok(_) => JsValue::from_str(&self.string_buf),
-            Err(e) => JsValue::from_str(&e.to_string()),
+        if let Err(err_vec) = Org::export_buf(s, &mut self.string_buf, ConfigOptions::default()) {
+            // clear here since the buf was used to store the results of the export
+            // REVIEW: maybe have an error_buf to avoid the clear here?
+            self.string_buf.clear();
+            for e in err_vec {
+                self.string_buf.push_str(&e.to_string());
+                self.string_buf.push_str("\n");
+            }
         }
+        JsValue::from_str(&self.string_buf)
     }
 
     #[wasm_bindgen]
     pub fn to_html(&mut self, s: &str) -> JsValue {
         self.string_buf.clear();
-
-        match Html::export_buf(s, &mut self.string_buf, ConfigOptions::default()) {
-            Ok(_) => JsValue::from_str(&self.string_buf),
-            Err(e) => JsValue::from_str(&e.to_string()),
+        let parsed = parse_org(s);
+
+        if let Err(err_vec) =
+            Html::export_tree(&parsed, &mut self.string_buf, ConfigOptions::default())
+        {
+            self.string_buf.clear();
+            self.string_buf.push_str("<pre><code>");
+            self.string_buf.clear();
+            for e in err_vec {
+                self.string_buf.push_str(&e.to_string());
+                self.string_buf.push_str("\n");
+            }
+            // for e in err_vec {
+            //     match e {
+            //         ExportError::LogicError { span, source } => {
+            //             self.string_buf.push_str(&source.to_string());
+            //             self.string_buf.push_str("\n\t\t");
+            //             self.string_buf.push_str(&parsed.source[span]);
+            //         }
+            //         ExportError::WriteError(f) => {
+            //             self.string_buf.push_str(&f.to_string());
+            //         }
+            //     }
+            //     // self.string_buf.push_str(&e.to_string());
+            //     self.string_buf.push_str("\n");
+            // }
+            self.string_buf.push_str("</pre></code>");
         }
+        JsValue::from_str(&self.string_buf)
     }
 }
 

From 1a32a216e7c5ec7b6cda3acdc00b7b5caa141743 Mon Sep 17 00:00:00 2001
From: Laith <laithbahodi@gmail.com>
Date: Mon, 23 Sep 2024 00:23:06 -0400
Subject: [PATCH 13/14] refactor: make ExportInner infalliable

since we now coalesce errors and don't use the ? syntax, the only other
source of those were in write!() calls. we almost exclusively write! to
in memory string buffers (or maybe stdout), so I expect write! to never
fail (at least not without the entire program catastrophically failing
right alongside it)

aside:
I guess someone could pass in some network thing as a buffer where
failure is more likely but it's not like we're recovering from a failure
anyways.

all that being said, I decided to use unwrap to just have the program
explode if write! fails. it's more appropriate than failing silently
since clearly something disastrous has happened and a panic would be
what I want in that scenario. it feels icky to cause a panic but I think
it's what a programmer would want in that scenario (and it'll almost
never happen)
---
 crates/org-exporter/src/html.rs    | 460 +++++++++++++++--------------
 crates/org-exporter/src/include.rs |   5 +-
 crates/org-exporter/src/org.rs     | 334 ++++++++++-----------
 crates/org-exporter/src/types.rs   |   8 +-
 4 files changed, 409 insertions(+), 398 deletions(-)

diff --git a/crates/org-exporter/src/html.rs b/crates/org-exporter/src/html.rs
index 11a85cb..894b7a1 100644
--- a/crates/org-exporter/src/html.rs
+++ b/crates/org-exporter/src/html.rs
@@ -15,11 +15,16 @@ use org_parser::{parse_macro_call, parse_org, Expr, Node, NodeID, Parser};
 
 use crate::include::include_handle;
 use crate::org_macros::macro_handle;
-use crate::types::{ConfigOptions, Exporter, ExporterInner, LogicErrorKind, Result};
+use crate::types::{ConfigOptions, Exporter, ExporterInner, LogicErrorKind};
 use crate::utils::{process_toc, Options, TocItem};
 use crate::ExportError;
 use phf::phf_set;
 
+macro_rules! w {
+    ($dst:expr, $($arg:tt)*) => {
+        $dst.write_fmt(format_args!($($arg)*)).expect("writing to buffer during export failed")
+    };
+}
 // file types we can wrap an `img` around
 static IMAGE_TYPES: phf::Set<&str> = phf_set! {
     "jpeg",
@@ -164,21 +169,20 @@ fn handle_toc<'a, T: fmt::Write + ExporterInner<'a>>(
     parsed: &Parser,
     writer: &mut T,
     tocs: &Vec<TocItem>,
-) -> Result<()> {
-    write!(
+) {
+    w!(
         writer,
         r#"<nav id="table-of-contents" role="doc-toc">
 <h2>Table Of Contents</h2>
 <div id="text-table-of-contents" role="doc-toc">
 "#
-    )?;
-    write!(writer, "<ul>")?;
+    );
+    w!(writer, "<ul>");
     for toc in tocs {
-        toc_rec(&parsed, writer, toc, 1)?;
+        toc_rec(&parsed, writer, toc, 1);
     }
-    write!(writer, "</ul>")?;
-    write!(writer, r#"</div></nav>"#)?;
-    Ok(())
+    w!(writer, "</ul>");
+    w!(writer, r#"</div></nav>"#);
 }
 
 fn toc_rec<'a, T: fmt::Write + ExporterInner<'a>>(
@@ -186,29 +190,27 @@ fn toc_rec<'a, T: fmt::Write + ExporterInner<'a>>(
     writer: &mut T,
     parent: &TocItem,
     curr_level: u8,
-) -> Result<()> {
-    write!(writer, "<li>")?;
+) {
+    w!(writer, "<li>");
     if curr_level < parent.level {
-        write!(writer, "<ul>")?;
-        toc_rec(&parser, writer, parent, curr_level + 1)?;
-        write!(writer, "</ul>")?;
+        w!(writer, "<ul>");
+        toc_rec(&parser, writer, parent, curr_level + 1);
+        w!(writer, "</ul>");
     } else {
-        write!(writer, r#"<a href=#{}>"#, parent.target)?;
+        w!(writer, r#"<a href=#{}>"#, parent.target);
         for id in parent.name {
-            writer.export_rec(id, parser)?;
+            writer.export_rec(id, parser);
         }
-        write!(writer, "</a>")?;
+        w!(writer, "</a>");
         if !parent.children.is_empty() {
-            write!(writer, "<ul>")?;
+            w!(writer, "<ul>");
             for child in &parent.children {
-                toc_rec(&parser, writer, child, curr_level + 1)?;
+                toc_rec(&parser, writer, child, curr_level + 1);
             }
-            write!(writer, "</ul>")?;
+            w!(writer, "</ul>");
         }
     }
-    write!(writer, "</li>")?;
-
-    Ok(())
+    w!(writer, "</li>");
 }
 
 impl<'buf> ExporterInner<'buf> for Html<'buf> {
@@ -235,36 +237,36 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
         }
     }
 
-    fn export_rec(&mut self, node_id: &NodeID, parser: &Parser) -> Result<()> {
+    fn export_rec(&mut self, node_id: &NodeID, parser: &Parser) {
         // avoid parsing this node
         if self.nox.contains(node_id) {
-            return Ok(());
+            return;
         }
         let node = &parser.pool[*node_id];
         match &node.obj {
             Expr::Root(inner) => {
                 for id in inner {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
             }
             Expr::Heading(inner) => {
                 let heading_number: u8 = inner.heading_level.into();
 
-                write!(self, "<h{heading_number}",)?;
-                self.prop(node)?;
-                write!(self, ">")?;
+                w!(self, "<h{heading_number}");
+                self.prop(node);
+                w!(self, ">");
 
                 if let Some(title) = &inner.title {
                     for id in &title.1 {
-                        self.export_rec(id, parser)?;
+                        self.export_rec(id, parser);
                     }
                 }
 
-                writeln!(self, "</h{heading_number}>")?;
+                w!(self, "</h{heading_number}>\n");
 
                 if let Some(children) = &inner.children {
                     for id in children {
-                        self.export_rec(id, parser)?;
+                        self.export_rec(id, parser);
                     }
                 }
             }
@@ -276,31 +278,31 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                         contents,
                     } => {
                         if parameters.get("exports").is_some_and(|&x| x == "none") {
-                            return Ok(());
+                            return;
                         }
-                        write!(self, "<div")?;
-                        self.class("org-center")?;
-                        self.prop(node)?;
-                        writeln!(self, ">")?;
+                        w!(self, "<div");
+                        self.class("org-center");
+                        self.prop(node);
+                        w!(self, ">\n");
                         for id in contents {
-                            self.export_rec(id, parser)?;
+                            self.export_rec(id, parser);
                         }
-                        writeln!(self, "</div>")?;
+                        w!(self, "</div>\n");
                     }
                     Block::Quote {
                         parameters,
                         contents,
                     } => {
                         if parameters.get("exports").is_some_and(|&x| x == "none") {
-                            return Ok(());
+                            return;
                         }
-                        write!(self, "<blockquote")?;
-                        self.prop(node)?;
-                        writeln!(self, ">")?;
+                        w!(self, "<blockquote");
+                        self.prop(node);
+                        w!(self, ">\n");
                         for id in contents {
-                            self.export_rec(id, parser)?;
+                            self.export_rec(id, parser);
                         }
-                        writeln!(self, "</blockquote>")?;
+                        w!(self, "</blockquote>\n");
                     }
                     Block::Special {
                         parameters,
@@ -308,26 +310,26 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                         name,
                     } => {
                         if parameters.get("exports").is_some_and(|&x| x == "none") {
-                            return Ok(());
+                            return;
                         }
                         // html5 names are directly converted into tags
                         if HTML5_TYPES.contains(name) {
-                            write!(self, "<{name}")?;
-                            self.prop(node)?;
-                            writeln!(self, ">")?;
+                            w!(self, "<{name}");
+                            self.prop(node);
+                            w!(self, ">\n");
                             for id in contents {
-                                self.export_rec(id, parser)?;
+                                self.export_rec(id, parser);
                             }
-                            write!(self, "</{name}>")?;
+                            w!(self, "</{name}>");
                         } else {
-                            write!(self, "<div")?;
-                            self.prop(node)?;
-                            self.class(name)?;
-                            writeln!(self, ">")?;
+                            w!(self, "<div");
+                            self.prop(node);
+                            self.class(name);
+                            w!(self, ">\n");
                             for id in contents {
-                                self.export_rec(id, parser)?;
+                                self.export_rec(id, parser);
                             }
-                            writeln!(self, "</div>")?;
+                            w!(self, "</div>\n");
                         }
                     }
 
@@ -337,21 +339,21 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                         contents,
                     } => {
                         if parameters.get("exports").is_some_and(|&x| x == "none") {
-                            return Ok(());
+                            return;
                         }
-                        writeln!(self, "<!--{contents}-->")?;
+                        w!(self, "<!--{contents}-->\n");
                     }
                     Block::Example {
                         parameters,
                         contents,
                     } => {
                         if parameters.get("exports").is_some_and(|&x| x == "none") {
-                            return Ok(());
+                            return;
                         }
-                        write!(self, "<pre")?;
-                        self.class("example")?;
-                        self.prop(node)?;
-                        writeln!(self, ">\n{}</pre>", HtmlEscape(contents))?;
+                        w!(self, "<pre");
+                        self.class("example");
+                        self.prop(node);
+                        w!(self, ">\n{}</pre>\n", HtmlEscape(contents));
                     }
                     Block::Export {
                         backend,
@@ -359,10 +361,10 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                         contents,
                     } => {
                         if parameters.get("exports").is_some_and(|&x| x == "none") {
-                            return Ok(());
+                            return;
                         }
                         if backend.is_some_and(|x| x == Html::backend_name()) {
-                            writeln!(self, "{contents}")?;
+                            w!(self, "{contents}\n");
                         }
                     }
                     Block::Src {
@@ -371,29 +373,29 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                         contents,
                     } => {
                         if parameters.get("exports").is_some_and(|&x| x == "none") {
-                            return Ok(());
+                            return;
                         }
-                        write!(self, "<pre>")?;
-                        write!(self, "<code")?;
-                        self.class("src")?;
+                        w!(self, "<pre>");
+                        w!(self, "<code");
+                        self.class("src");
                         if let Some(lang) = language {
-                            self.class(&format!("src-{}", lang))?;
+                            self.class(&format!("src-{}", lang));
                         }
-                        self.prop(node)?;
-                        writeln!(self, ">\n{}</pre></code>", HtmlEscape(contents))?;
+                        self.prop(node);
+                        w!(self, ">\n{}</pre></code>\n", HtmlEscape(contents));
                     }
                     Block::Verse {
                         parameters,
                         contents,
                     } => {
                         if parameters.get("exports").is_some_and(|&x| x == "none") {
-                            return Ok(());
+                            return;
                         }
                         // FIXME: apparently verse blocks contain objects...
-                        write!(self, "<p")?;
-                        self.class("verse")?;
-                        self.prop(node)?;
-                        writeln!(self, ">\n{}</p>", HtmlEscape(contents))?;
+                        w!(self, "<p");
+                        self.class("verse");
+                        self.prop(node);
+                        w!(self, ">\n{}</p>\n", HtmlEscape(contents));
                     }
                 }
             }
@@ -424,15 +426,15 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                     }
                     PathReg::File(a) => format!("{a}"),
                 };
-                write!(self, r#"<a href="{}">"#, HtmlEscape(&path_link))?;
+                w!(self, r#"<a href="{}">"#, HtmlEscape(&path_link));
                 if let Some(children) = &inner.description {
                     for id in children {
-                        self.export_rec(id, parser)?;
+                        self.export_rec(id, parser);
                     }
                 } else {
-                    write!(self, "{}", HtmlEscape(inner.path.to_str(parser.source)))?;
+                    w!(self, "{}", HtmlEscape(inner.path.to_str(parser.source)));
                 }
-                write!(self, "</a>")?;
+                w!(self, "</a>");
             }
 
             Expr::Paragraph(inner) => {
@@ -453,14 +455,14 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                         let ending_tag = link_source.split('.').last();
                         if let Some(extension) = ending_tag {
                             if IMAGE_TYPES.contains(extension) {
-                                write!(self, "<figure>\n<img")?;
-                                self.prop(node)?;
-                                write!(self, r#" src="{}""#, HtmlEscape(link_source))?;
+                                w!(self, "<figure>\n<img");
+                                self.prop(node);
+                                w!(self, r#" src="{}""#, HtmlEscape(link_source));
                                 // start writing alt (if there are children)
-                                write!(self, r#" alt=""#)?;
+                                w!(self, r#" alt=""#);
                                 if let Some(children) = &link.description {
                                     for id in children {
-                                        self.export_rec(id, parser)?;
+                                        self.export_rec(id, parser);
                                     }
                                 } else {
                                     let alt_text: Cow<str> =
@@ -469,114 +471,112 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                                         } else {
                                             link_source.into()
                                         };
-                                    write!(self, "{}", HtmlEscape(alt_text))?;
+                                    w!(self, "{}", HtmlEscape(alt_text));
                                 }
-                                write!(self, "\">\n</figure>")?;
-                                return Ok(());
+                                w!(self, "\">\n</figure>");
+                                return;
                             }
                         }
                     }
                 }
-                write!(self, "<p")?;
-                self.prop(node)?;
-                write!(self, ">")?;
+                w!(self, "<p");
+                self.prop(node);
+                w!(self, ">");
 
                 for id in &inner.0 {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
-                writeln!(self, "</p>")?;
+                w!(self, "</p>\n");
             }
 
             Expr::Italic(inner) => {
-                write!(self, "<em>")?;
+                w!(self, "<em>");
                 for id in &inner.0 {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
-                write!(self, "</em>")?;
+                w!(self, "</em>");
             }
             Expr::Bold(inner) => {
-                write!(self, "<b>")?;
+                w!(self, "<b>");
                 for id in &inner.0 {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
-                write!(self, "</b>")?;
+                w!(self, "</b>");
             }
             Expr::StrikeThrough(inner) => {
-                write!(self, "<del>")?;
+                w!(self, "<del>");
                 for id in &inner.0 {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
-                write!(self, "</del>")?;
+                w!(self, "</del>");
             }
             Expr::Underline(inner) => {
-                write!(self, "<u>")?;
+                w!(self, "<u>");
                 for id in &inner.0 {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
-                write!(self, "</u>")?;
-                // write!(self, "<span class=underline>")?;
+                w!(self, "</u>");
+                // w!(self, "<span class=underline>")?;
                 // for id in &inner.0 {
-                //     self.export_rec(id, parser)?;
+                //     self.export_rec(id, parser);
                 // }
-                // write!(self, "</span>")?;
+                // w!(self, "</span>")?;
             }
             Expr::BlankLine => {
-                // write!(self, "\n")?;
+                // w!(self, "\n")?;
             }
             Expr::SoftBreak => {
-                write!(self, " ")?;
+                w!(self, " ");
             }
             Expr::LineBreak => {
-                writeln!(self, "\n<br>")?;
+                w!(self, "\n<br>\n");
             }
             Expr::HorizontalRule => {
-                writeln!(self, "\n<hr>")?;
+                w!(self, "\n<hr>\n");
             }
             Expr::Plain(inner) => {
-                write!(self, "{}", HtmlEscape(inner))?;
+                w!(self, "{}", HtmlEscape(inner));
             }
             Expr::Verbatim(inner) => {
-                write!(self, "<code>{}</code>", HtmlEscape(inner.0))?;
+                w!(self, "<code>{}</code>", HtmlEscape(inner.0));
             }
             Expr::Code(inner) => {
-                write!(self, "<code>{}</code>", HtmlEscape(inner.0))?;
+                w!(self, "<code>{}</code>", HtmlEscape(inner.0));
             }
             Expr::Comment(inner) => {
-                write!(self, "<!--{}-->", inner.0)?;
+                w!(self, "<!--{}-->", inner.0);
             }
             Expr::InlineSrc(inner) => {
-                write!(
+                w!(
                     self,
                     "<code class={}>{}</code>",
                     inner.lang,
                     HtmlEscape(inner.body)
-                )?;
+                );
                 // if let Some(args) = inner.headers {
-                //     write!(self, "[{args}]")?;
+                //     w!(self, "[{args}]")?;
                 // }
-                // write!(self, "{{{}}}", inner.body)?;
+                // w!(self, "{{{}}}", inner.body)?;
             }
             Expr::Keyword(inner) => {
                 if inner.key.to_ascii_lowercase() == "include" {
-                    write!(self, r#"<div class="org-include""#)?;
-                    self.prop(node)?;
-                    write!(self, ">")?;
-
-                    // TODO have vec to store errors instead of blowing up
+                    w!(self, r#"<div class="org-include""#);
+                    self.prop(node);
+                    w!(self, ">");
 
                     if let Err(e) = include_handle(inner.val, self) {
                         self.errors().push(ExportError::LogicError {
                             span: node.start..node.end,
                             source: LogicErrorKind::Include(e),
                         });
-                        return Ok(());
+                        return;
                     }
 
                     //     .map_err(|e| ExportError::LogicError {
                     //     span: node.start..node.end,
                     //     source: LogicErrorKind::Include(e),
                     // })?;
-                    write!(self, "</div>")?;
+                    w!(self, "</div>");
                 }
             }
             Expr::LatexEnv(inner) => {
@@ -588,49 +588,57 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                     inner.name, inner.contents
                 );
                 let ret = latex_to_mathml(&formatted, DisplayStyle::Block);
-                writeln!(self, "{}", if let Ok(val) = &ret { val } else { formatted })?;
+                // TODO/FIXME: this should be an error
+                w!(
+                    self,
+                    "{}\n",
+                    if let Ok(val) = &ret { val } else { formatted }
+                );
             }
             Expr::LatexFragment(inner) => match inner {
                 LatexFragment::Command { name, contents } => {
                     let mut pot_cont = String::new();
-                    write!(pot_cont, r#"{name}"#)?;
+                    w!(pot_cont, r#"{name}"#);
                     if let Some(command_cont) = contents {
-                        write!(pot_cont, "{{{command_cont}}}")?;
+                        w!(pot_cont, "{{{command_cont}}}");
                     }
-                    write!(
+                    // TODO/FIXME: this should be an error
+                    w!(
                         self,
                         "{}",
                         &latex_to_mathml(&pot_cont, DisplayStyle::Inline).unwrap(),
-                    )?;
+                    );
                 }
                 LatexFragment::Display(inner) => {
-                    writeln!(
+                    // TODO/FIXME: this should be an error
+                    w!(
                         self,
-                        "{}",
+                        "{}\n",
                         &latex_to_mathml(inner, DisplayStyle::Block).unwrap()
-                    )?;
+                    );
                 }
                 LatexFragment::Inline(inner) => {
-                    write!(
+                    // TODO/FIXME: this should be an error
+                    w!(
                         self,
                         "{}",
                         &latex_to_mathml(inner, DisplayStyle::Inline).unwrap()
-                    )?;
+                    );
                 }
             },
             Expr::Item(inner) => {
                 if let Some(tag) = inner.tag {
-                    write!(self, "<dt>{}</dt>", HtmlEscape(tag))?;
-                    write!(self, "<dd>")?;
+                    w!(self, "<dt>{}</dt>", HtmlEscape(tag));
+                    w!(self, "<dd>");
                     for id in &inner.children {
-                        self.export_rec(id, parser)?;
+                        self.export_rec(id, parser);
                     }
-                    write!(self, "</dd>")?;
+                    w!(self, "</dd>");
                 } else {
-                    write!(self, "<li")?;
+                    w!(self, "<li");
 
                     if let Some(counter) = inner.counter_set {
-                        self.attr("value", counter)?;
+                        self.attr("value", counter);
                     }
 
                     if let Some(check) = &inner.check_box {
@@ -638,16 +646,16 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                             CheckBox::Intermediate => "trans",
                             CheckBox::Off => "off",
                             CheckBox::On => "on",
-                        })?;
+                        });
                     }
 
-                    write!(self, ">")?;
+                    w!(self, ">");
 
                     for id in &inner.children {
-                        self.export_rec(id, parser)?;
+                        self.export_rec(id, parser);
                     }
 
-                    writeln!(self, "</li>")?;
+                    w!(self, "</li>\n");
                 }
             }
             Expr::PlainList(inner) => {
@@ -665,96 +673,97 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                     },
                     ListKind::Descriptive => ("dd", ""),
                 };
-                write!(self, "<{tag}{desc}")?;
-                self.prop(node)?;
-                writeln!(self, ">")?;
+                w!(self, "<{tag}{desc}");
+                self.prop(node);
+                w!(self, ">\n");
                 for id in &inner.children {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
-                writeln!(self, "</{tag}>")?;
+                w!(self, "</{tag}>\n");
             }
             Expr::PlainLink(inner) => {
-                write!(
+                w!(
                     self,
                     "<a href={0}:{1}>{0}:{1}</a>",
-                    inner.protocol, inner.path
-                )?;
+                    inner.protocol,
+                    inner.path
+                );
             }
             Expr::Entity(inner) => {
-                write!(self, "{}", inner.mapped_item)?;
+                w!(self, "{}", inner.mapped_item);
             }
             Expr::Table(inner) => {
-                write!(self, "<table")?;
-                self.prop(node)?;
-                writeln!(self, ">")?;
+                w!(self, "<table");
+                self.prop(node);
+                w!(self, ">\n");
 
                 for id in &inner.children {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
 
-                writeln!(self, "</table>")?;
+                w!(self, "</table>\n");
             }
 
             Expr::TableRow(inner) => {
                 match inner {
                     TableRow::Rule => { /*skip*/ }
                     TableRow::Standard(stands) => {
-                        writeln!(self, "<tr>")?;
+                        w!(self, "<tr>\n");
                         for id in stands.iter() {
-                            self.export_rec(id, parser)?;
+                            self.export_rec(id, parser);
                         }
-                        writeln!(self, "</tr>")?;
+                        w!(self, "</tr>\n");
                     }
                 }
             }
             Expr::TableCell(inner) => {
-                write!(self, "<td>")?;
+                w!(self, "<td>");
                 for id in &inner.0 {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
-                writeln!(self, "</td>")?;
+                w!(self, "</td>\n");
             }
             Expr::Emoji(inner) => {
-                write!(self, "{}", inner.mapped_item)?;
+                w!(self, "{}", inner.mapped_item);
             }
             Expr::Superscript(inner) => {
-                write!(self, "<sup>")?;
+                w!(self, "<sup>");
                 match &inner.0 {
                     PlainOrRec::Plain(inner) => {
-                        write!(self, "{inner}")?;
+                        w!(self, "{inner}");
                     }
                     PlainOrRec::Rec(inner) => {
                         for id in inner {
-                            self.export_rec(id, parser)?;
+                            self.export_rec(id, parser);
                         }
                     }
                 }
-                write!(self, "</sup>")?;
+                w!(self, "</sup>");
             }
             Expr::Subscript(inner) => {
-                write!(self, "<sub>")?;
+                w!(self, "<sub>");
                 match &inner.0 {
                     PlainOrRec::Plain(inner) => {
-                        write!(self, "{inner}")?;
+                        w!(self, "{inner}");
                     }
                     PlainOrRec::Rec(inner) => {
                         for id in inner {
-                            self.export_rec(id, parser)?;
+                            self.export_rec(id, parser);
                         }
                     }
                 }
-                write!(self, "</sub>")?;
+                w!(self, "</sub>");
             }
             Expr::Target(inner) => {
-                write!(self, "<span")?;
-                self.prop(node)?;
-                write!(self, ">")?;
-                write!(
+                w!(self, "<span");
+                self.prop(node);
+                w!(self, ">");
+                w!(
                     self,
                     "<span id={}>{}</span>",
                     parser.pool[*node_id].id_target.as_ref().unwrap(), // must exist
                     HtmlEscape(inner.0)
-                )?;
+                );
             }
             Expr::Macro(macro_call) => {
                 let macro_contents = match macro_handle(parser, macro_call, self.config_opts()) {
@@ -764,7 +773,7 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                             span: node.start..node.end,
                             source: LogicErrorKind::Macro(e),
                         });
-                        return Ok(());
+                        return;
                     }
                 };
 
@@ -774,34 +783,34 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                             Html::export_macro_buf(&p, self, self.config_opts().clone())
                         {
                             self.errors().append(&mut err_vec);
-                            return Ok(());
+                            // TODO alert for errors handled within macro
                         }
                     }
                     Cow::Borrowed(r) => {
-                        write!(self, "{}", HtmlEscape(r))?;
+                        w!(self, "{}", HtmlEscape(r));
                     }
                 }
             }
             Expr::Drawer(inner) => {
                 for id in &inner.children {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
             }
             Expr::ExportSnippet(inner) => {
                 if inner.backend == Html::backend_name() {
-                    write!(self, "{}", inner.contents)?;
+                    w!(self, "{}", inner.contents);
                 }
             }
             Expr::Affiliated(inner) => match inner {
                 Affiliated::Name(_id) => {}
                 Affiliated::Caption(id, contents) => {
                     if let Some(caption_id) = id {
-                        writeln!(self, "<figure>")?;
-                        self.export_rec(caption_id, parser)?;
-                        writeln!(self, "<figcaption>")?;
-                        self.export_rec(contents, parser)?;
-                        writeln!(self, "</figcaption>")?;
-                        writeln!(self, "</figure>")?;
+                        w!(self, "<figure>\n");
+                        self.export_rec(caption_id, parser);
+                        w!(self, "<figcaption>\n");
+                        self.export_rec(contents, parser);
+                        w!(self, "</figcaption>\n");
+                        w!(self, "</figure>\n");
                         self.nox.insert(*caption_id);
                     }
                 }
@@ -842,17 +851,16 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
                     format!("{index}")
                 };
 
-                write!(
+                w!(
                     self,
                     r##"<sup>
     <a id="fnr.{0}" href="#fn.{1}" class="footref" role="doc-backlink">{1}</a>
 </sup>"##,
-                    fn_id, index,
-                )?;
+                    fn_id,
+                    index,
+                );
             }
         }
-
-        Ok(())
     }
 
     fn backend_name() -> &'static str {
@@ -870,35 +878,31 @@ impl<'buf> ExporterInner<'buf> for Html<'buf> {
 // Writers for generic attributes
 impl<'buf> Html<'buf> {
     /// Adds a property
-    fn prop(&mut self, node: &Node) -> Result<()> {
+    fn prop(&mut self, node: &Node) {
         // if the target needs an id
         if let Some(tag_contents) = node.id_target.as_ref() {
-            write!(self, r#" id="{tag_contents}""#)?;
+            w!(self, r#" id="{tag_contents}""#);
         }
 
         // attach any keys that need to be placed
         if let Some(attrs) = node.attrs.get(Html::backend_name()) {
             for (key, val) in attrs {
-                self.attr(key, val)?;
+                self.attr(key, val);
             }
         }
-
-        Ok(())
     }
 
-    fn class(&mut self, name: &str) -> Result<()> {
-        write!(self, r#" class="{name}""#)?;
-        Ok(())
+    fn class(&mut self, name: &str) {
+        w!(self, r#" class="{name}""#);
     }
 
-    fn attr(&mut self, key: &str, val: &str) -> Result<()> {
-        write!(self, r#" {}="{}""#, key, HtmlEscape(val))?;
-        Ok(())
+    fn attr(&mut self, key: &str, val: &str) {
+        w!(self, r#" {}="{}""#, key, HtmlEscape(val));
     }
 
-    fn exp_footnotes(&mut self, parser: &Parser) -> Result<()> {
+    fn exp_footnotes(&mut self, parser: &Parser) {
         if self.footnotes.is_empty() {
-            return Ok(());
+            return;
         }
 
         // get last heading, and check if its title is Footnotes,
@@ -914,7 +918,7 @@ impl<'buf> Html<'buf> {
             false
         });
 
-        writeln!(
+        w!(
             self,
             r#"
 <div id="footnotes">
@@ -922,14 +926,23 @@ impl<'buf> Html<'buf> {
     .footdef p {{
     display:inline;
     }}
-    </style>"#
-        )?;
+    </style>
+"#
+        );
 
         if heading_query.is_none() {
-            writeln!(self, r#"    <h2 class="footnotes">Footnotes</h2>"#)?;
+            w!(
+                self,
+                r#"    <h2 class="footnotes">Footnotes</h2>
+"#
+            );
         }
 
-        writeln!(self, r#"    <div id="text-footnotes">"#)?;
+        w!(
+            self,
+            r#"    <div id="text-footnotes">
+"#
+        );
 
         // FIXME
         // lifetime shenanigans making me do this.. can't figure em out
@@ -938,7 +951,7 @@ impl<'buf> Html<'buf> {
         let man = self.footnotes.clone();
         for (mut pos, def_id) in man.iter().enumerate() {
             pos += 1;
-            write!(
+            w!(
                 self,
                 r##"
 
@@ -947,26 +960,25 @@ impl<'buf> Html<'buf> {
     <a id="fn.{pos}" href= "#fnr.{pos}" role="doc-backlink">{pos}</a>
 </sup>
 "##
-            )?;
+            );
             match &parser.pool[*def_id].obj {
                 Expr::FootnoteDef(fn_def) => {
                     for child_id in &fn_def.children {
-                        self.export_rec(child_id, parser)?;
+                        self.export_rec(child_id, parser);
                     }
                 }
                 Expr::FootnoteRef(fn_ref) => {
                     if let Some(children) = fn_ref.children.as_ref() {
                         for child_id in children {
-                            self.export_rec(child_id, parser)?;
+                            self.export_rec(child_id, parser);
                         }
                     }
                 }
                 _ => (),
             }
-            write!(self, r#"</div>"#)?;
+            w!(self, r#"</div>"#);
         }
-        write!(self, "\n  </div>\n</div>")?;
-        Ok(())
+        w!(self, "\n  </div>\n</div>");
     }
 }
 
diff --git a/crates/org-exporter/src/include.rs b/crates/org-exporter/src/include.rs
index a4dcccf..82dea92 100644
--- a/crates/org-exporter/src/include.rs
+++ b/crates/org-exporter/src/include.rs
@@ -275,9 +275,8 @@ pub(crate) fn include_handle<'a>(
     // TODO: only-contents
 
     parsed = parse_org(&feed_str);
-    writer
-        .export_rec(&parsed.pool.root_id(), &parsed)
-        .map_err(|e| Box::new(e))?;
+    // TODO/FIXME: expose these errors
+    writer.export_rec(&parsed.pool.root_id(), &parsed);
 
     Ok(())
 }
diff --git a/crates/org-exporter/src/org.rs b/crates/org-exporter/src/org.rs
index 285861f..30489e1 100644
--- a/crates/org-exporter/src/org.rs
+++ b/crates/org-exporter/src/org.rs
@@ -4,7 +4,7 @@ use std::fmt::Write;
 
 use crate::include::include_handle;
 use crate::org_macros::macro_handle;
-use crate::types::{ConfigOptions, Exporter, ExporterInner, LogicErrorKind, Result};
+use crate::types::{ConfigOptions, Exporter, ExporterInner, LogicErrorKind};
 use crate::ExportError;
 use org_parser::element::{Block, BulletKind, CounterKind, Priority, TableRow, Tag};
 use org_parser::object::{LatexFragment, PlainOrRec};
@@ -26,6 +26,12 @@ pub struct Org<'buf> {
     errors: Vec<ExportError>,
 }
 
+macro_rules! w {
+    ($dst:expr, $($arg:tt)*) => {
+        $dst.write_fmt(format_args!($($arg)*)).expect("writing to buffer during export failed")
+    };
+}
+
 impl<'buf> Exporter<'buf> for Org<'buf> {
     fn export(input: &str, conf: ConfigOptions) -> core::result::Result<String, Vec<ExportError>> {
         let mut buf = String::new();
@@ -89,38 +95,38 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
         }
     }
 
-    fn export_rec(&mut self, node_id: &NodeID, parser: &Parser) -> Result<()> {
+    fn export_rec(&mut self, node_id: &NodeID, parser: &Parser) {
         let node = &parser.pool[*node_id];
         match &node.obj {
             Expr::Root(inner) => {
                 for id in inner {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
             }
             Expr::Heading(inner) => {
                 for _ in 0..inner.heading_level.into() {
-                    write!(self, "*")?;
+                    w!(self, "*");
                 }
-                write!(self, " ")?;
+                w!(self, " ");
 
                 if let Some(keyword) = inner.keyword {
-                    write!(self, "{keyword} ")?;
+                    w!(self, "{keyword} ");
                 }
 
                 if let Some(priority) = &inner.priority {
-                    write!(self, "[#")?;
+                    w!(self, "[#");
                     match priority {
-                        Priority::A => write!(self, "A")?,
-                        Priority::B => write!(self, "B")?,
-                        Priority::C => write!(self, "C")?,
-                        Priority::Num(num) => write!(self, "{num}")?,
+                        Priority::A => w!(self, "A"),
+                        Priority::B => w!(self, "B"),
+                        Priority::C => w!(self, "C"),
+                        Priority::Num(num) => w!(self, "{num}"),
                     };
-                    write!(self, "] ")?;
+                    w!(self, "] ");
                 }
 
                 if let Some(title) = &inner.title {
                     for id in &title.1 {
-                        self.export_rec(id, parser)?;
+                        self.export_rec(id, parser);
                     }
                 }
 
@@ -129,7 +135,7 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                 //         if let Some(sub_tags) = loc.tags.as_ref() {
                 //             for thang in sub_tags.iter().rev() {
                 //                 match thang {
-                //                     Tag::Raw(val) => write!(self, ":{val}")?,
+                //                     Tag::Raw(val) => w!(self, ":{val}"),
                 //                     Tag::Loc(id, parser) => {
                 //                         tag_search(*id, pool, self)?;
                 //                     }
@@ -144,7 +150,7 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                     let mut valid_out = String::new();
                     for tag in tags.iter().rev() {
                         match tag {
-                            Tag::Raw(val) => write!(&mut valid_out, ":{val}")?,
+                            Tag::Raw(val) => w!(&mut valid_out, ":{val}"),
                             Tag::Loc(_id) => {
                                 // do nothing with it
                             }
@@ -152,15 +158,15 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                     }
                     // handles the case where a parent heading has no tags
                     if !valid_out.is_empty() {
-                        write!(self, " {valid_out}:")?;
+                        w!(self, " {valid_out}:");
                     }
                 }
 
-                writeln!(self)?;
+                w!(self, "\n");
 
                 if let Some(children) = &inner.children {
                     for id in children {
-                        self.export_rec(id, parser)?;
+                        self.export_rec(id, parser);
                     }
                 }
             }
@@ -171,44 +177,44 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                         parameters,
                         contents,
                     } => {
-                        write!(self, "#+begin_center")?;
+                        w!(self, "#+begin_center");
                         for (key, val) in parameters {
-                            write!(self, " :{} {}", key, val)?;
+                            w!(self, " :{} {}", key, val);
                         }
-                        writeln!(self)?;
+                        w!(self, "\n");
                         for id in contents {
-                            self.export_rec(id, parser)?;
+                            self.export_rec(id, parser);
                         }
-                        writeln!(self, "#+end_center")?;
+                        w!(self, "#+end_center\n");
                     }
                     Block::Quote {
                         parameters,
                         contents,
                     } => {
-                        writeln!(self, "#+begin_quote")?;
+                        w!(self, "#+begin_quote");
                         for (key, val) in parameters {
-                            write!(self, " :{} {}", key, val)?;
+                            w!(self, " :{} {}", key, val);
                         }
-                        writeln!(self)?;
+                        w!(self, "\n");
                         for id in contents {
-                            self.export_rec(id, parser)?;
+                            self.export_rec(id, parser);
                         }
-                        writeln!(self, "#+end_quote")?;
+                        w!(self, "#+end_quote\n");
                     }
                     Block::Special {
                         parameters,
                         contents,
                         name,
                     } => {
-                        write!(self, "#+begin_{name}")?;
+                        w!(self, "#+begin_{name}");
                         for (key, val) in parameters {
-                            write!(self, " :{} {}", key, val)?;
+                            w!(self, " :{} {}", key, val);
                         }
-                        writeln!(self)?;
+                        w!(self, "\n");
                         for id in contents {
-                            self.export_rec(id, parser)?;
+                            self.export_rec(id, parser);
                         }
-                        writeln!(self, "#+end_{name}")?;
+                        w!(self, "#+end_{name}\n");
                     }
 
                     // Lesser blocks
@@ -216,23 +222,23 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                         parameters,
                         contents,
                     } => {
-                        write!(self, "#+begin_comment")?;
+                        w!(self, "#+begin_comment");
                         for (key, val) in parameters {
-                            write!(self, " :{} {}", key, val)?;
+                            w!(self, " :{} {}", key, val);
                         }
-                        write!(self, "\n{contents}")?;
-                        writeln!(self, "#+end_comment")?;
+                        w!(self, "\n{contents}");
+                        w!(self, "#+end_comment\n");
                     }
                     Block::Example {
                         parameters,
                         contents,
                     } => {
-                        write!(self, "#+begin_example")?;
+                        w!(self, "#+begin_example");
                         for (key, val) in parameters {
-                            write!(self, " :{} {}", key, val)?;
+                            w!(self, " :{} {}", key, val);
                         }
-                        write!(self, "\n{contents}")?;
-                        writeln!(self, "#+end_example")?;
+                        w!(self, "\n{contents}");
+                        w!(self, "#+end_example\n");
                     }
                     Block::Export {
                         backend,
@@ -240,12 +246,12 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                         contents,
                     } => {
                         let back = if let Some(word) = backend { word } else { "" };
-                        write!(self, "#+begin_export {}", back)?;
+                        w!(self, "#+begin_export {}", back);
                         for (key, val) in parameters {
-                            write!(self, " :{} {}", key, val)?;
+                            w!(self, " :{} {}", key, val);
                         }
-                        write!(self, "\n{contents}")?;
-                        writeln!(self, "#+end_export")?;
+                        w!(self, "\n{contents}");
+                        w!(self, "#+end_export\n");
                     }
                     Block::Src {
                         language,
@@ -253,104 +259,104 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                         contents,
                     } => {
                         let lang = if let Some(word) = language { word } else { "" };
-                        write!(self, "#+begin_src {}", lang)?;
+                        w!(self, "#+begin_src {}", lang);
                         for (key, val) in parameters {
-                            write!(self, " :{} {}", key, val)?;
+                            w!(self, " :{} {}", key, val);
                         }
-                        write!(self, "\n{contents}")?;
-                        writeln!(self, "#+end_src")?;
+                        w!(self, "\n{contents}");
+                        w!(self, "#+end_src\n");
                     }
                     Block::Verse {
                         parameters,
                         contents,
                     } => {
-                        write!(self, "#+begin_verse")?;
+                        w!(self, "#+begin_verse");
                         for (key, val) in parameters {
-                            write!(self, " :{} {}", key, val)?;
+                            w!(self, " :{} {}", key, val);
                         }
-                        write!(self, "\n{contents}")?;
-                        writeln!(self, "#+end_verse")?;
+                        w!(self, "\n{contents}");
+                        w!(self, "#+end_verse\n");
                     }
                 }
             }
             Expr::RegularLink(inner) => {
-                write!(self, "[")?;
-                write!(self, "[{}]", inner.path.obj)?;
+                w!(self, "[");
+                w!(self, "[{}]", inner.path.obj);
                 if let Some(children) = &inner.description {
-                    write!(self, "[")?;
+                    w!(self, "[");
                     for id in children {
-                        self.export_rec(id, parser)?;
+                        self.export_rec(id, parser);
                     }
-                    write!(self, "]")?;
+                    w!(self, "]");
                 }
-                write!(self, "]")?;
+                w!(self, "]");
             }
 
             Expr::Paragraph(inner) => {
                 for id in &inner.0 {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
-                writeln!(self)?;
+                w!(self, "\n");
             }
 
             Expr::Italic(inner) => {
-                write!(self, "/")?;
+                w!(self, "/");
                 for id in &inner.0 {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
-                write!(self, "/")?;
+                w!(self, "/");
             }
             Expr::Bold(inner) => {
-                write!(self, "*")?;
+                w!(self, "*");
                 for id in &inner.0 {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
-                write!(self, "*")?;
+                w!(self, "*");
             }
             Expr::StrikeThrough(inner) => {
-                write!(self, "+")?;
+                w!(self, "+");
                 for id in &inner.0 {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
-                write!(self, "+")?;
+                w!(self, "+");
             }
             Expr::Underline(inner) => {
-                write!(self, "_")?;
+                w!(self, "_");
                 for id in &inner.0 {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
-                write!(self, "_")?;
+                w!(self, "_");
             }
             Expr::BlankLine => {
-                writeln!(self)?;
+                w!(self, "\n");
             }
             Expr::SoftBreak => {
-                write!(self, " ")?;
+                w!(self, " ");
             }
             Expr::LineBreak => {
-                write!(self, r#"\\"#)?;
+                w!(self, r#"\\"#);
             }
             Expr::HorizontalRule => {
-                writeln!(self, "-----")?;
+                w!(self, "-----\n");
             }
             Expr::Plain(inner) => {
-                write!(self, "{inner}")?;
+                w!(self, "{inner}");
             }
             Expr::Verbatim(inner) => {
-                write!(self, "={}=", inner.0)?;
+                w!(self, "={}=", inner.0);
             }
             Expr::Code(inner) => {
-                write!(self, "~{}~", inner.0)?;
+                w!(self, "~{}~", inner.0);
             }
             Expr::Comment(inner) => {
-                writeln!(self, "# {}", inner.0)?;
+                w!(self, "# {}\n", inner.0);
             }
             Expr::InlineSrc(inner) => {
-                write!(self, "src_{}", inner.lang)?;
+                w!(self, "src_{}", inner.lang);
                 if let Some(args) = inner.headers {
-                    write!(self, "[{args}]")?;
+                    w!(self, "[{args}]");
                 }
-                write!(self, "{{{}}}", inner.body)?;
+                w!(self, "{{{}}}", inner.body);
             }
             Expr::Keyword(inner) => {
                 if inner.key.to_ascii_lowercase() == "include" {
@@ -359,66 +365,67 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                             span: node.start..node.end,
                             source: LogicErrorKind::Include(e),
                         });
-                        return Ok(());
+                        return;
                     }
                 }
             }
             Expr::LatexEnv(inner) => {
-                write!(
+                w!(
                     self,
                     r"\begin{{{0}}}
 {1}
 \end{{{0}}}
 ",
-                    inner.name, inner.contents
-                )?;
+                    inner.name,
+                    inner.contents
+                );
             }
             Expr::LatexFragment(inner) => match inner {
                 LatexFragment::Command { name, contents } => {
-                    write!(self, r#"\{name}"#)?;
+                    w!(self, r#"\{name}"#);
                     if let Some(command_cont) = contents {
-                        write!(self, "{{{command_cont}}}")?;
+                        w!(self, "{{{command_cont}}}");
                     }
                 }
                 LatexFragment::Display(inner) => {
-                    write!(self, r"\[{inner}\]")?;
+                    w!(self, r"\[{inner}\]");
                 }
                 LatexFragment::Inline(inner) => {
-                    write!(self, r#"\({inner}\)"#)?;
+                    w!(self, r#"\({inner}\)"#);
                 }
             },
             Expr::Item(inner) => {
                 match inner.bullet {
                     BulletKind::Unordered => {
-                        write!(self, "-")?;
+                        w!(self, "-");
                     }
                     BulletKind::Ordered(counterkind) => match counterkind {
                         CounterKind::Letter(lettre) => {
-                            write!(self, "{}.", lettre as char)?;
+                            w!(self, "{}.", lettre as char);
                         }
                         CounterKind::Number(num) => {
-                            write!(self, "{num}.")?;
+                            w!(self, "{num}.");
                         }
                     },
                 }
-                write!(self, " ")?;
+                w!(self, " ");
 
                 if let Some(counter_set) = inner.counter_set {
-                    write!(self, "[@{counter_set}]")?;
+                    w!(self, "[@{counter_set}]");
                 }
 
                 if let Some(check) = &inner.check_box {
                     let val: &str = check.into();
-                    write!(self, "[{val}] ")?;
+                    w!(self, "[{val}] ");
                 }
 
                 if let Some(tag) = inner.tag {
-                    write!(self, "{tag} :: ")?;
+                    w!(self, "{tag} :: ");
                 }
 
                 self.indentation_level += 1;
                 for id in &inner.children {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
                 self.indentation_level -= 1;
                 if self.indentation_level == 0 {
@@ -427,14 +434,14 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
             }
             Expr::PlainList(inner) => {
                 for id in &inner.children {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
             }
             Expr::PlainLink(inner) => {
-                write!(self, "[[{}:{}]]", inner.protocol, inner.path)?;
+                w!(self, "[[{}:{}]]", inner.protocol, inner.path);
             }
             Expr::Entity(inner) => {
-                write!(self, "{}", inner.mapped_item)?;
+                w!(self, "{}", inner.mapped_item);
             }
             Expr::Table(inner) => {
                 let mut build_vec: Vec<Vec<String>> = Vec::with_capacity(inner.rows);
@@ -442,7 +449,8 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                 // in lists, manually retrigger it here
 
                 for _ in 0..self.indentation_level {
-                    self.buf.write_str("  ")?;
+                    // w!(self, "  ");
+                    self.buf.write_str("  ").unwrap();
                 }
                 self.on_newline = false;
 
@@ -463,7 +471,7 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                                             conf: self.conf.clone(),
                                             errors: Vec::new(),
                                         };
-                                        new_obj.export_rec(id, parser)?;
+                                        new_obj.export_rec(id, parser);
                                         row_vec.push(cell_buf);
                                     }
                                 }
@@ -493,20 +501,20 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                 }
 
                 for row in &build_vec {
-                    write!(self, "|")?;
+                    w!(self, "|");
 
                     // is hrule
                     if row.is_empty() {
                         for (i, val) in col_widths.iter().enumerate() {
                             // + 2 to account for buffer around cells
                             for _ in 0..(*val + 2) {
-                                write!(self, "-")?;
+                                w!(self, "-");
                             }
 
                             if i == inner.cols {
-                                write!(self, "|")?;
+                                w!(self, "|");
                             } else {
-                                write!(self, "+")?;
+                                w!(self, "+");
                             }
                         }
                     } else {
@@ -515,23 +523,23 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                             let diff;
 
                             // left buffer
-                            write!(self, " ")?;
+                            w!(self, " ");
                             if let Some(strang) = cell {
                                 diff = col_width - strang.len();
-                                write!(self, "{strang}")?;
+                                w!(self, "{strang}");
                             } else {
                                 diff = *col_width;
                             };
 
                             for _ in 0..diff {
-                                write!(self, " ")?;
+                                w!(self, " ");
                             }
 
                             // right buffer + ending
-                            write!(self, " |")?;
+                            w!(self, " |");
                         }
                     }
-                    writeln!(self)?;
+                    w!(self, "\n");
                 }
             }
 
@@ -540,40 +548,40 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
             }
             Expr::TableCell(inner) => {
                 for id in &inner.0 {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
             }
             Expr::Emoji(inner) => {
-                write!(self, "{}", inner.mapped_item)?;
+                w!(self, "{}", inner.mapped_item);
             }
             Expr::Superscript(inner) => match &inner.0 {
                 PlainOrRec::Plain(inner) => {
-                    write!(self, "^{{{inner}}}")?;
+                    w!(self, "^{{{inner}}}");
                 }
                 PlainOrRec::Rec(inner) => {
-                    write!(self, "^{{")?;
+                    w!(self, "^{{");
                     for id in inner {
-                        self.export_rec(id, parser)?;
+                        self.export_rec(id, parser);
                     }
 
-                    write!(self, "}}")?;
+                    w!(self, "}}");
                 }
             },
             Expr::Subscript(inner) => match &inner.0 {
                 PlainOrRec::Plain(inner) => {
-                    write!(self, "_{{{inner}}}")?;
+                    w!(self, "_{{{inner}}}");
                 }
                 PlainOrRec::Rec(inner) => {
-                    write!(self, "_{{")?;
+                    w!(self, "_{{");
                     for id in inner {
-                        self.export_rec(id, parser)?;
+                        self.export_rec(id, parser);
                     }
 
-                    write!(self, "}}")?;
+                    w!(self, "}}");
                 }
             },
             Expr::Target(inner) => {
-                write!(self, "<<{}>>", inner.0)?;
+                w!(self, "<<{}>>", inner.0);
             }
             Expr::Macro(macro_call) => {
                 let macro_contents = match macro_handle(parser, macro_call, self.config_opts()) {
@@ -583,7 +591,7 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                             span: node.start..node.end,
                             source: LogicErrorKind::Macro(e),
                         });
-                        return Ok(());
+                        return;
                     }
                 };
 
@@ -593,51 +601,49 @@ impl<'buf> ExporterInner<'buf> for Org<'buf> {
                             Org::export_macro_buf(&p, self, self.config_opts().clone())
                         {
                             self.errors().append(&mut err_vec);
-                            return Ok(());
+                            return;
                         }
                     }
                     Cow::Borrowed(r) => {
-                        write!(self, "{r}")?;
+                        w!(self, "{r}");
                     }
                 }
             }
             Expr::Drawer(inner) => {
-                writeln!(self, ":{}:", inner.name)?;
+                w!(self, ":{}:\n", inner.name);
                 for id in &inner.children {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
-                writeln!(self, ":end:")?;
+                w!(self, ":end:\n");
             }
             Expr::ExportSnippet(inner) => {
                 if inner.backend == "org" {
-                    write!(self, "{}", inner.contents)?;
+                    w!(self, "{}", inner.contents);
                 }
             }
             Expr::Affiliated(_) => {}
             Expr::MacroDef(_) => {}
             Expr::FootnoteDef(inner) => {
-                write!(self, r"[fn:{}] ", inner.label)?;
+                w!(self, r"[fn:{}] ", inner.label);
 
                 for id in &inner.children {
-                    self.export_rec(id, parser)?;
+                    self.export_rec(id, parser);
                 }
             }
             Expr::FootnoteRef(inner) => {
-                write!(self, r"[fn:")?;
+                w!(self, r"[fn:");
                 if let Some(label) = inner.label {
-                    write!(self, "{label}")?;
+                    w!(self, "{label}");
                 }
                 if let Some(descr) = &inner.children {
-                    write!(self, ":")?;
+                    w!(self, ":");
                     for id in descr {
-                        self.export_rec(id, parser)?;
+                        self.export_rec(id, parser);
                     }
                 }
-                write!(self, "]")?;
+                w!(self, "]");
             }
         }
-
-        Ok(())
     }
 
     fn backend_name() -> &'static str {
@@ -688,7 +694,7 @@ mod tests {
     }
 
     #[test]
-    fn basic_org_export()  {
+    fn basic_org_export() {
         let out_str = org_export(
             r"** one two
 three
@@ -707,7 +713,7 @@ three *four*
     }
 
     #[test]
-    fn fancy_list_export()  {
+    fn fancy_list_export() {
         let a = org_export(
             r"
     + one two three
@@ -735,13 +741,13 @@ four five six
     }
 
     #[test]
-    fn test_link_export()  {
+    fn test_link_export() {
         let out = org_export("[[https://swag.org][meowww]]");
         println!("{out}");
     }
 
     #[test]
-    fn test_beeg()  {
+    fn test_beeg() {
         let out = org_export(
             r"* DONE [#0] *one* two /three/ /four*       :one:two:three:four:
 more content here this is a pargraph
@@ -880,7 +886,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn less()  {
+    fn less() {
         let out = org_export(
             r"* [#1] abc :c:
 ** [#1] descendant headline :a:b:
@@ -901,7 +907,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn list_export()  {
+    fn list_export() {
         let a = org_export(
             r"
 - one
@@ -930,7 +936,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn basic_list_export()  {
+    fn basic_list_export() {
         let a = org_export(
             r"
 - one
@@ -961,7 +967,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn list_words()  {
+    fn list_words() {
         let a: String = org_export(
             r"
 1. item 1
@@ -998,7 +1004,7 @@ more content here this is a pargraph
         //         );
     }
     #[test]
-    fn table_export()  {
+    fn table_export() {
         let a = org_export(
             r"
 |one|two|
@@ -1020,7 +1026,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn table_export_hrule()  {
+    fn table_export_hrule() {
         let a = org_export(
             r"
 |one|two|
@@ -1052,7 +1058,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn indented_table()  {
+    fn indented_table() {
         let a = org_export(
             r"
 - zero
@@ -1086,7 +1092,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn proper_list_indent()  {
+    fn proper_list_indent() {
         let a = org_export(
             r"
 - one
@@ -1108,7 +1114,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn heading_list_not()  {
+    fn heading_list_not() {
         let a = org_export(
             r"
 - one
@@ -1131,7 +1137,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn proper_link()  {
+    fn proper_link() {
         let a = org_export(r"[[abc][one]]");
 
         assert_eq!(
@@ -1139,11 +1145,10 @@ more content here this is a pargraph
             r"[[abc][one]]
 "
         );
-
     }
 
     #[test]
-    fn link_odd()  {
+    fn link_odd() {
         let a = org_export("[aayyyy][one]]");
         assert_eq!(
             a,
@@ -1153,7 +1158,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn superscript()  {
+    fn superscript() {
         let a = org_export(r"sample_text^{\gamma}");
         assert_eq!(
             a,
@@ -1182,7 +1187,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn subscript()  {
+    fn subscript() {
         let a = org_export(r"sample_text_{\gamma}");
         assert_eq!(
             a,
@@ -1208,11 +1213,10 @@ more content here this is a pargraph
             r"nowhere _texto
 "
         );
-
     }
 
     #[test]
-    fn plain_link()  {
+    fn plain_link() {
         let a = org_export("https://cool.com abc rest");
 
         assert_eq!(
@@ -1223,7 +1227,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn newline_literal_markup()  {
+    fn newline_literal_markup() {
         let a = org_export(
             r"- test =if ~literal $interpreters \[handle newline \(properly {{{in(a lists
 - text that isn't disappearing!
@@ -1239,7 +1243,7 @@ more content here this is a pargraph
     }
 
     #[test]
-    fn lblock_plus_list()  {
+    fn lblock_plus_list() {
         let a = org_export(
             r"
 -
@@ -1258,7 +1262,7 @@ meowwwwwwwwww
     }
 
     #[test]
-    fn markup_enclosed_in_bracks()  {
+    fn markup_enclosed_in_bracks() {
         let a = org_export(r"[_enclosed text here_]");
 
         assert_eq!(
@@ -1269,7 +1273,7 @@ meowwwwwwwwww
     }
 
     #[test]
-    fn drawer()  {
+    fn drawer() {
         let a = org_export(
             r"
 :NAME:
diff --git a/crates/org-exporter/src/types.rs b/crates/org-exporter/src/types.rs
index a291896..0259228 100644
--- a/crates/org-exporter/src/types.rs
+++ b/crates/org-exporter/src/types.rs
@@ -3,8 +3,6 @@ use org_parser::{NodeID, Parser};
 use std::{ops::Range, path::PathBuf};
 use thiserror::Error;
 
-pub(crate) type Result<T> = core::result::Result<T, ExportError>;
-
 use crate::{include::IncludeError, org_macros::MacroError};
 
 #[derive(Debug, Clone, Default)]
@@ -20,8 +18,6 @@ pub enum ExportError {
         span: Range<usize>,
         source: LogicErrorKind,
     },
-    #[error("{0}")]
-    WriteError(#[from] fmt::Error),
 }
 
 #[derive(Debug, Error)]
@@ -75,7 +71,7 @@ pub trait Exporter<'buf> {
 pub(crate) trait ExporterInner<'buf> {
     /// Entry point of the exporter to handle macros.
     ///
-    /// Exporting macros entails creating a new context and parsing objects,
+    /// Exporting macros entails creating a new context which parses objects,
     /// as opposed to elements.
     fn export_macro_buf<'inp, T: fmt::Write>(
         input: &'inp str,
@@ -85,7 +81,7 @@ pub(crate) trait ExporterInner<'buf> {
     /// Primary exporting routine.
     ///
     /// This method is called recursively until every `Node` in the tree is exhausted.
-    fn export_rec(&mut self, node_id: &NodeID, parser: &Parser) -> Result<()>;
+    fn export_rec(&mut self, node_id: &NodeID, parser: &Parser);
     /// The canonical name of the exporting backend
     /// REVIEW: make public?
     fn backend_name() -> &'static str;

From 8749786417061375dde884491a7f6e1a900f279c Mon Sep 17 00:00:00 2001
From: Laith <laithbahodi@gmail.com>
Date: Mon, 18 Nov 2024 11:44:10 -0500
Subject: [PATCH 14/14] chore: upgrade versions

---
 crates/org-cli/Cargo.toml      | 10 +++++-----
 crates/org-exporter/Cargo.toml |  4 ++--
 crates/org-parser/Cargo.toml   |  2 +-
 pkg/aur/PKGBUILD               |  2 +-
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/crates/org-cli/Cargo.toml b/crates/org-cli/Cargo.toml
index 100563f..fa75b80 100644
--- a/crates/org-cli/Cargo.toml
+++ b/crates/org-cli/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "org-rust"
-version = "0.1.16"
+version = "0.1.17"
 description = "CLI tool for converting Org-Mode documents to other formats"
 keywords = ["org-mode", "parser"]
 categories = ["command-line-utilities"]
@@ -18,8 +18,8 @@ rust-version.workspace = true
 clap = { version = "4.3.11", features = ["derive"] }
 lazy_format = "2.0.0"
 regex = "1.9.5"
-org-exporter = { version = "0.1.6", path = "../org-exporter", package = "org-rust-exporter" }
-org-parser =   { version = "0.1.4", path = "../org-parser", package = "org-rust-parser" }
+org-exporter = { version = "0.1.8", path = "../org-exporter", package = "org-rust-exporter" }
+org-parser =   { version = "0.1.5", path = "../org-parser", package = "org-rust-parser" }
 serde = { version = "1.0.196", features=["derive"]}
 toml = "0.8.8"
 anyhow = "1.0.82"
@@ -30,8 +30,8 @@ clap = { version = "4.3.11", features=["derive"]}
 clap_complete = "4.3.2"
 clap_mangen = "0.2.14"
 serde = { version = "1.0.196", features=["derive"]}
-org-exporter = { version = "0.1.2", path = "../org-exporter", package = "org-rust-exporter" }
-org-parser =   { version = "0.1.2", path = "../org-parser", package = "org-rust-parser" }
+org-exporter = { version = "0.1.8", path = "../org-exporter", package = "org-rust-exporter" }
+org-parser =   { version = "0.1.5", path = "../org-parser", package = "org-rust-parser" }
 
 
 # [[bin]]
diff --git a/crates/org-exporter/Cargo.toml b/crates/org-exporter/Cargo.toml
index df2b407..d51a246 100644
--- a/crates/org-exporter/Cargo.toml
+++ b/crates/org-exporter/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "org-rust-exporter"
-version = "0.1.7"
+version = "0.1.8"
 description = "exporter for org mode documents parsed with `org-rust-parser`"
 
 homepage.workspace = true
@@ -14,7 +14,7 @@ rust-version.workspace = true
 [dependencies]
 latex2mathml = "0.2.3"
 memchr = "2.5.0"
-org-parser = { version = "0.1.3", path = "../org-parser", package = "org-rust-parser" }
+org-parser = { version = "0.1.5", path = "../org-parser", package = "org-rust-parser" }
 phf = {version = "0.11.1", features = ["macros"]}
 thiserror = "1.0.63"
 
diff --git a/crates/org-parser/Cargo.toml b/crates/org-parser/Cargo.toml
index 7e8d140..eb4688b 100644
--- a/crates/org-parser/Cargo.toml
+++ b/crates/org-parser/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "org-rust-parser"
-version = "0.1.4"
+version = "0.1.5"
 description = "parser for org mode documents"
 
 homepage.workspace = true
diff --git a/pkg/aur/PKGBUILD b/pkg/aur/PKGBUILD
index 8e04d8e..22d7ef4 100644
--- a/pkg/aur/PKGBUILD
+++ b/pkg/aur/PKGBUILD
@@ -1,7 +1,7 @@
 # Maintainer: aquabeam <laithbahodi@gmail.com>
 
 pkgname=org-rust
-pkgver=0.1.16
+pkgver=0.1.17
 pkgrel=1
 url=https://github.com/hydrobeam/org-rust
 pkgdesc='CLI tool for converting Org-Mode documents to other formats'