From 07301930560a5f162998e651392ac0bc7c2b5f5f Mon Sep 17 00:00:00 2001
From: Alexandre Bury <alexandre.bury@gmail.com>
Date: Thu, 20 Jun 2024 15:10:19 -0400
Subject: [PATCH] Rewrite cursup parsing without regexes

---
 cursive-core/Cargo.toml                 |   5 -
 cursive-core/src/printer.rs             |   7 +
 cursive-core/src/theme/style.rs         |  46 ++--
 cursive-core/src/utils/markup/cursup.rs | 265 ++++++++++++++++++------
 cursive/Cargo.toml                      |   1 -
 5 files changed, 248 insertions(+), 76 deletions(-)

diff --git a/cursive-core/Cargo.toml b/cursive-core/Cargo.toml
index 48fcf655..0ce23831 100644
--- a/cursive-core/Cargo.toml
+++ b/cursive-core/Cargo.toml
@@ -60,10 +60,6 @@ version = "0.8"
 default-features = false
 version = "0.4"
 
-[dependencies.regex]
-optional = true
-version = "1"
-
 [dependencies.pulldown-cmark]
 default-features = false
 optional = true
@@ -73,7 +69,6 @@ version = "0.11"
 default = []
 doc-cfg = []
 builder = ["inventory", "cursive-macros/builder"]
-cursup = ["regex"]
 markdown = ["pulldown-cmark"]
 ansi = ["ansi-parser"]
 unstable_scroll = []  # Deprecated feature, remove in next version
diff --git a/cursive-core/src/printer.rs b/cursive-core/src/printer.rs
index 4a49d0b5..ccb7b3b7 100644
--- a/cursive-core/src/printer.rs
+++ b/cursive-core/src/printer.rs
@@ -300,6 +300,13 @@ impl<'a, 'b> Printer<'a, 'b> {
         }
     }
 
+    /// Fills a rectangle using the given character.
+    pub fn print_rect(&self, rect: Rect, c: &str) {
+        for y in rect.top()..=rect.bottom() {
+            self.print_hline((rect.left(), y), rect.width(), c);
+        }
+    }
+
     /// Prints a horizontal line using the given character.
     pub fn print_hline<T: Into<Vec2>>(&self, start: T, width: usize, c: &str) {
         let start = start.into();
diff --git a/cursive-core/src/theme/style.rs b/cursive-core/src/theme/style.rs
index 2c6dc52f..d62b93a9 100644
--- a/cursive-core/src/theme/style.rs
+++ b/cursive-core/src/theme/style.rs
@@ -165,19 +165,29 @@ impl Style {
     }
 }
 
+fn parse_single_style(s: &str) -> Result<Style, super::NoSuchColor> {
+    if let Some(s) = s.strip_prefix("back.") {
+        if let Ok(back) = s.parse::<ColorType>() {
+            return Ok(ColorStyle::back(back).into());
+        }
+    }
+
+    if let Ok(front) = s.parse::<ColorType>() {
+        return Ok(front.into());
+    }
+
+    if let Ok(effect) = s.parse::<Effect>() {
+        return Ok(effect.into());
+    }
+
+    Err(super::NoSuchColor)
+}
+
 impl FromStr for Style {
     type Err = super::NoSuchColor;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if let Ok(front) = s.parse::<ColorType>() {
-            return Ok(front.into());
-        }
-
-        if let Ok(effect) = s.parse::<Effect>() {
-            return Ok(effect.into());
-        }
-
-        Err(super::NoSuchColor)
+        s.split('+').map(parse_single_style).collect()
     }
 }
 
@@ -374,23 +384,35 @@ impl From<PaletteStyle> for StyleType {
 /// Will use the last non-`None` color, and will combine all effects.
 impl<'a> FromIterator<&'a Style> for Style {
     fn from_iter<I: IntoIterator<Item = &'a Style>>(iter: I) -> Style {
+        combine_styles(iter)
+    }
+}
+
+impl AsRef<Style> for Style {
+    fn as_ref(&self) -> &Style {
+        self
+    }
+}
+
+fn combine_styles<S: AsRef<Style>>(styles: impl IntoIterator<Item=S>) -> Style {
         let mut color = ColorStyle::inherit_parent();
         let mut effects = Effects::empty();
 
-        for style in iter {
+        for style in styles {
+            let style = style.as_ref();
             color = ColorStyle::merge(color, style.color);
             effects = Effects::merge(effects, style.effects);
         }
 
         Style { effects, color }
-    }
 }
 
 /// Creates a new `Style` by merging all given styles.
 ///
 /// Will use the last non-`None` color, and will combine all effects.
 impl<T: Into<Style>> FromIterator<T> for Style {
+    // TODO: Find some common implementation for both?
     fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Style {
-        iter.into_iter().map(Into::into).collect()
+        combine_styles(iter.into_iter().map(Into::into))
     }
 }
diff --git a/cursive-core/src/utils/markup/cursup.rs b/cursive-core/src/utils/markup/cursup.rs
index 18783140..89f3fa0c 100644
--- a/cursive-core/src/utils/markup/cursup.rs
+++ b/cursive-core/src/utils/markup/cursup.rs
@@ -2,85 +2,146 @@
 //!
 //! # Examples
 //!
-//! ```
+//! ```cursup
 //! /red{This} /green{text} /blue{is} /bold{very} /underline{styled}!
 //! /red+bold{This too!}
 //! ```
-#![cfg(feature = "cursup")]
+//!
+//! ```
+//! # use cursive_core as cursive;
+//! use cursive::utils::markup::cursup;
+//! use cursive::views::Button;
+//!
+//! // Highlight a letter from the word to show a shortcut available.
+//! Button::new(cursup::parse("/red{Q}uit"), |s| s.quit());
+//! ```
 #![cfg_attr(feature = "doc-cfg", doc(cfg(feature = "cursup")))]
+
 use crate::theme::Style;
 use crate::utils::markup::{StyledIndexedSpan, StyledString};
 use crate::utils::span::IndexedCow;
 
 use unicode_width::UnicodeWidthStr;
 
-/// Parse spans for the given text.
-pub fn parse_spans(input: &str) -> Vec<StyledIndexedSpan> {
-    let mut result = Vec::new();
-
-    let re = regex::Regex::new(r"\/(?:(\w+)(?:\+(\w+))*)\{(.+)\}").unwrap();
-
-    let mut offset = 0;
-    let mut content = input;
-    while let Some(c) = re.captures(content) {
-        let m = c.get(0).unwrap();
-        let start = m.start();
-        let end = m.end();
-
-        // First, append the entire content up to here.
-        if start != 0 {
-            result.push(StyledIndexedSpan {
-                content: IndexedCow::Borrowed {
-                    start: offset,
-                    end: offset + start,
-                },
-                attr: Style::default(),
-                width: content[..start].width(),
-            });
-        }
-
-        let len = c.len();
-        assert!(
-            len > 2,
-            "The regex should always yield at least 2 groups (+ the entire match)."
-        );
-        let body = c.get(len - 1).unwrap();
+enum State {
+    Plain,
+    Slash(usize),
+}
 
-        let mut style = Style::default();
+struct Candidate {
+    slash: usize,
+    brace: usize,
+}
 
-        for i in 1..len - 1 {
-            let Some(action) = c.get(i) else {
-                continue;
-            };
+#[derive(Debug)]
+enum Event {
+    Start(Style),
+    End,
+    StartSkip,
+    Resume,
+}
 
-            style = style.combine(action.as_str().parse::<Style>().unwrap());
+/// Parse spans for the given text.
+pub fn parse_spans(input: &str) -> Vec<StyledIndexedSpan> {
+    let mut candidates = Vec::<Candidate>::new();
+    let mut state = State::Plain;
+    let mut events = Vec::new();
+
+    for (i, b) in input.bytes().enumerate() {
+        match (&mut state, b) {
+            (State::Plain, b'/') => {
+                state = State::Slash(i);
+            }
+            (State::Plain | State::Slash(_), b'}') if !candidates.is_empty() => {
+                // Validate this span
+                let candidate = candidates.pop().unwrap();
+
+                let action = &input[candidate.slash + 1..candidate.brace];
+                let style = action.parse::<Style>().unwrap_or_default();
+
+                events.push((candidate.slash, Event::StartSkip));
+                events.push((candidate.brace + 1, Event::Start(style)));
+                events.push((i, Event::End));
+                events.push((i + 1, Event::Resume));
+            }
+            (State::Plain, _) => (),
+
+            (State::Slash(_), b'a'..=b'z' | b'+' | b'.') => (),
+            (State::Slash(slash), b'{') => {
+                // Add a candidate.
+                candidates.push(Candidate {
+                    slash: *slash,
+                    brace: i,
+                });
+                state = State::Plain;
+            }
+            (State::Slash(ref mut start), b'/') => {
+                // The previous slash is unusable, try with this one.
+                *start = i;
+            }
+            (State::Slash(_), _) => {
+                // Unsupported char found.
+                state = State::Plain;
+            }
         }
-
-        result.push(StyledIndexedSpan {
-            content: IndexedCow::Borrowed {
-                start: offset + body.start(),
-                end: offset + body.end(),
-            },
-            attr: style,
-            width: body.as_str().width(),
-        });
-
-        content = &content[end..];
-        offset += end;
     }
 
-    if !content.is_empty() {
-        result.push(StyledIndexedSpan {
+    events.sort_by_key(|(i, _)| *i);
+
+    let mut spans = Vec::new();
+    let mut style_stack = vec![Style::default()];
+
+    let mut cursor = 0;
+    for (i, event) in events {
+        match event {
+            Event::Start(style) => {
+                // Flush everything between cursor and start.
+                let new_style = style_stack.last().unwrap().combine(style);
+                style_stack.push(new_style);
+            }
+            Event::StartSkip => {
+                // Flush things since cursor
+                if cursor != i {
+                    spans.push(StyledIndexedSpan {
+                        content: IndexedCow::Borrowed {
+                            start: cursor,
+                            end: i,
+                        },
+                        attr: *style_stack.last().unwrap(),
+                        width: input[cursor..i].width(),
+                    });
+                }
+            }
+            Event::End => {
+                // Just like StartSkip, but we pop a style from the stack.
+                if cursor != i {
+                    spans.push(StyledIndexedSpan {
+                        content: IndexedCow::Borrowed {
+                            start: cursor,
+                            end: i,
+                        },
+                        attr: *style_stack.last().unwrap(),
+                        width: input[cursor..i].width(),
+                    });
+                }
+                style_stack.pop();
+            }
+            Event::Resume => {}
+        }
+        cursor = i;
+    }
+    if cursor != input.len() {
+        spans.push(StyledIndexedSpan {
             content: IndexedCow::Borrowed {
-                start: offset,
-                end: offset + content.len(),
+                start: cursor,
+                end: input.len(),
             },
-            attr: Style::default(),
-            width: content.width(),
+            attr: *style_stack.last().unwrap(),
+            width: input[cursor..].width(),
         });
     }
 
-    result
+    spans
 }
 
 /// Parse the given text into a styled string.
@@ -94,3 +155,91 @@ where
 
     StyledString::with_spans(input, spans)
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::theme::{BaseColor, Effect, Style};
+    use crate::utils::markup::cursup::parse;
+    use crate::utils::markup::StyledString;
+    use crate::utils::span::Span;
+
+    #[test]
+    fn empty_string() {
+        let parsed = parse("");
+        assert_eq!(parsed, StyledString::new());
+    }
+
+    #[test]
+    fn plain() {
+        let parsed = parse("abc");
+        assert_eq!(parsed, StyledString::plain("abc"));
+    }
+
+    #[test]
+    fn single_span() {
+        let parsed = parse("/red{red}");
+        let spans: Vec<_> = parsed.spans().collect();
+        assert_eq!(
+            &spans,
+            &[Span {
+                content: "red",
+                width: 3,
+                attr: &Style::from_color_style(BaseColor::Red.dark().into())
+            }]
+        );
+    }
+
+    #[test]
+    fn span_and_plain() {
+        let parsed = parse("/red{Q}uit");
+        let spans: Vec<_> = parsed.spans().collect();
+        assert_eq!(
+            &spans,
+            &[
+                Span {
+                    content: "Q",
+                    width: 1,
+                    attr: &Style::from_color_style(BaseColor::Red.dark().into())
+                },
+                Span {
+                    content: "uit",
+                    width: 3,
+                    attr: &Style::default(),
+                }
+            ]
+        );
+    }
+
+    #[test]
+    fn nested() {
+        let parsed = parse("/red{foo /bold{bar} baz}");
+
+        let spans: Vec<_> = parsed.spans().collect();
+        assert_eq!(
+            spans,
+            &[
+                Span {
+                    content: "foo ",
+                    width: 4,
+                    attr: &Style::from_color_style(BaseColor::Red.dark().into())
+                },
+                Span {
+                    content: "bar",
+                    width: 3,
+                    attr: &Style::from_color_style(BaseColor::Red.dark().into()).combine(Effect::Bold)
+                },
+                Span {
+                    content: " baz",
+                    width: 4,
+                    attr: &Style::from_color_style(BaseColor::Red.dark().into())
+                }
+            ],
+        );
+    }
+
+    #[test]
+    fn invalid_span_as_plain_text() {
+        let parsed = parse("/red{red");
+        assert_eq!(parsed, StyledString::plain("/red{red"));
+    }
+}
diff --git a/cursive/Cargo.toml b/cursive/Cargo.toml
index 5545f84e..3a26f0b3 100644
--- a/cursive/Cargo.toml
+++ b/cursive/Cargo.toml
@@ -52,7 +52,6 @@ version = "0.27"
 doc-cfg = ["cursive_core/doc-cfg"]  # Enable doc_cfg, a nightly-only doc feature.
 builder = ["cursive_core/builder"]
 blt-backend = ["bear-lib-terminal"]
-cursup = ["cursive_core/cursup"]
 default = ["ncurses-backend"]
 ncurses-backend = ["ncurses", "maplit"]
 pancurses-backend = ["pancurses", "maplit"]