Rewrite parser to remove trailing '\n', fix changing tag in selection

Author: ranfdev

gemini/src/parser.rs

@@ -1,51 +1,101 @@
 use once_cell::sync::Lazy;
 use regex::Regex;
 static R_GEMINI_LINK: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^=>\s*(?P<href>\S*)\s*(?P<label>.*)").unwrap());
-
-#[derive(Debug)]
-pub enum PageElement {
-    Heading(String),
-    Quote(String),
-    Preformatted(String),
-    Text(String),
+    Lazy::new(|| Regex::new(r"^=>\s+(?P<href>\S+)(\s+(?P<label>.+))?").unwrap());
+
+// See gemini://gemini.circumlunar.space/docs/cheatsheet.gmi
+
+#[derive(Debug, Clone)]
+pub enum Tag {
+    Paragraph, // Is just a text line
+    Heading(u8),
+    BlockQuote,
+    CodeBlock,
+    UnorderedList,
+    Item,
     Link(String, Option<String>),
-    ListItem(String),
-    Empty,
+}
+
+#[derive(Debug, Clone)]
+pub enum Event<'a> {
+    Start(Tag),
+    End,
+    Text(&'a str),
+    BlankLine,
 }
 
 #[derive(Debug, Clone, Default)]
 pub struct Parser {
-    inside_pre: bool,
+    tag_stack: Vec<Tag>,
 }
 
 impl Parser {
     pub fn new() -> Self {
-        Self { inside_pre: false }
+        Self { tag_stack: vec![] }
     }
-    pub fn parse_line(&mut self, line: &str) -> PageElement {
+
+    /// Returns an `Event` when an event it's ready, else, `None`
+    // TODO: Make this work on text input of any length, don't impose the "line" chunk requirement
+    // some work has already been done, the pushed result is already structured to do so.
+    pub fn parse_line<'a>(&mut self, line: &'a str, res: &mut Vec<Event<'a>>) {
+        let parent_tag = self.tag_stack.last();
+
+        // Close pending multi-line tags
+        if matches!(parent_tag, Some(Tag::BlockQuote)) && !line.starts_with('>')
+            || matches!(parent_tag, Some(Tag::UnorderedList))
+        {
+            res.push(Event::End);
+            self.tag_stack.pop();
+        }
+
+        let parent_tag = self.tag_stack.last();
+
         if line.starts_with("```") {
-            self.inside_pre = !self.inside_pre;
-            PageElement::Empty
-        } else if self.inside_pre {
-            PageElement::Preformatted(line.to_string())
+            let inner_res = if let Some(Tag::CodeBlock) = parent_tag {
+                self.tag_stack.pop();
+                Event::End
+            } else {
+                self.tag_stack.push(Tag::CodeBlock);
+                Event::Start(Tag::CodeBlock)
+            };
+            res.push(inner_res);
+        } else if let Some(Tag::CodeBlock) = parent_tag {
+            res.push(Event::Text(line));
+        } else if line.trim().is_empty() {
+            res.push(Event::BlankLine);
         } else if line.starts_with('#') {
-            PageElement::Heading(line.to_string())
+            let line = line.trim_end();
+            let lvl = line.chars().filter(|c| *c == '#').count();
+            let heading = Tag::Heading(lvl as u8);
+            res.push(Event::Start(heading));
+
+            let text = line.trim_start_matches('#').trim_start();
+            res.push(Event::Text(text));
+            res.push(Event::End);
         } else if line.starts_with('>') {
-            PageElement::Quote(line.to_string())
+            if !matches!(parent_tag, Some(Tag::BlockQuote)) {
+                res.push(Event::Start(Tag::BlockQuote));
+            }
+            res.push(Event::Text(line.trim_start_matches('>')));
         } else if let Some(stripped) = line.strip_prefix("* ") {
-            PageElement::ListItem(stripped.to_string())
-        } else if let Some(captures) = R_GEMINI_LINK.captures(line) {
-            match (captures.name("href"), captures.name("label")) {
-                (Some(m_href), Some(m_label)) if !m_label.as_str().is_empty() => PageElement::Link(
-                    m_href.as_str().to_string(),
-                    Some(m_label.as_str().to_string()),
-                ),
-                (Some(m_href), _) => PageElement::Link(m_href.as_str().to_string(), None),
-                _ => PageElement::Empty,
+            if !matches!(parent_tag, Some(Tag::UnorderedList)) {
+                res.push(Event::Start(Tag::UnorderedList));
             }
+            res.push(Event::Start(Tag::Item));
+            res.push(Event::Text(stripped.trim_end()));
+            res.push(Event::End);
+        } else if let Some(captures) = R_GEMINI_LINK.captures(line.trim_end()) {
+            let href = captures.name("href").unwrap();
+            let label = captures.name("label").map(|x| x.as_str());
+            res.push(Event::Start(Tag::Link(
+                href.as_str().to_string(),
+                label.map(|x| x.to_string()),
+            )));
+            res.push(Event::End);
         } else {
-            PageElement::Text(line.to_string())
+            res.push(Event::Start(Tag::Paragraph));
+            res.push(Event::Text(line.trim_end()));
+            res.push(Event::End);
         }
     }
 }

src/text_extensions/gemini.rs

@@ -123,74 +123,6 @@ impl Gemini {
             .unwrap()
             .set_foreground_rgba(Some(color));
     }
-    pub fn insert_heading(&self, text_iter: &mut gtk::TextIter, line: &str) {
-        let n = line.chars().filter(|c| *c == '#').count();
-        let line = line.trim_start_matches('#').trim_start();
-        let tag_name = match n {
-            1 => "h1",
-            2 => "h2",
-            _ => "h3",
-        };
-
-        let start = text_iter.offset();
-
-        self.text_buffer.insert(text_iter, line);
-        self.text_buffer.apply_tag_by_name(
-            tag_name,
-            &self.text_buffer.iter_at_offset(start),
-            &self.text_buffer.end_iter(),
-        );
-    }
-
-    pub fn insert_quote(&self, text_iter: &mut gtk::TextIter, line: &str) {
-        let start = text_iter.offset();
-        self.text_buffer.insert(text_iter, line);
-        self.text_buffer
-            .apply_tag_by_name("q", &self.text_buffer.iter_at_offset(start), text_iter);
-    }
-
-    pub fn insert_preformatted(&self, text_iter: &mut gtk::TextIter, line: &str) {
-        let start = text_iter.offset();
-        self.text_buffer.insert(text_iter, line);
-        self.text_buffer.apply_tag_by_name(
-            "pre",
-            &self.text_buffer.iter_at_offset(start),
-            text_iter,
-        );
-
-        self.text_buffer.insert(text_iter, "\n");
-    }
-    pub fn insert_paragraph(&self, text_iter: &mut gtk::TextIter, line: &str) {
-        let start = text_iter.offset();
-        self.text_buffer.insert(text_iter, line);
-        self.text_buffer
-            .apply_tag_by_name("p", &self.text_buffer.iter_at_offset(start), text_iter);
-    }
-    pub fn insert_link(
-        &mut self,
-        text_iter: &mut gtk::TextIter,
-        link: &str,
-        label: Option<&str>,
-    ) -> gtk::TextTag {
-        let start = text_iter.offset();
-
-        let tag = gtk::TextTag::new(None);
-        self.text_buffer.tag_table().add(&tag);
-
-        let label = label.unwrap_or(link);
-        self.insert_paragraph(text_iter, label);
-        self.insert_paragraph(text_iter, "\n");
-
-        self.text_buffer
-            .apply_tag(&tag, &self.text_buffer.iter_at_offset(start), text_iter);
-        self.text_buffer
-            .apply_tag_by_name("a", &self.text_buffer.iter_at_offset(start), text_iter);
-        tag
-    }
-    pub fn insert_list_item(&mut self, text_iter: &mut gtk::TextIter, text: &str) {
-        self.insert_paragraph(text_iter, " •  ");
-        self.insert_paragraph(text_iter, text);
-    }
     pub fn clear(&mut self) {
         let b = &self.text_buffer;
         b.delete(&mut b.start_iter(), &mut b.end_iter());