Don't depend on ansi parser types in the core

Author: bugadani

src/parser/mod.rs

@@ -16,7 +16,6 @@
 //!     tokens
 //! );
 //! ```
-use ansi_parser::AnsiSequence;
 use core::{marker::PhantomData, str::Chars};
 use embedded_graphics::{prelude::PixelColor, text::DecorationColor};
 
@@ -69,8 +68,13 @@ where
     /// Change of text style.
     ChangeTextStyle(ChangeTextStyle<C>),
 
-    /// An ANSI escape sequence
-    EscapeSequence(AnsiSequence),
+    /// Move the cursor by a number of characters.
+    MoveCursor {
+        /// Number of characters to move.
+        chars: i32,
+        /// True to draw over the area of movement with the background color.
+        draw_background: bool,
+    },
 }
 
 /// Text parser. Turns a string into a stream of [`Token`] objects.

src/plugin/ansi/mod.rs

@@ -1,8 +1,12 @@
 //! Ansi sequence support plugin
 
-use embedded_graphics::prelude::PixelColor;
+use ansi_parser::AnsiSequence;
+use embedded_graphics::{pixelcolor::Rgb888, prelude::PixelColor};
 
-use crate::{plugin::Plugin, Token};
+use crate::{
+    plugin::{ansi::utils::try_parse_sgr, Plugin},
+    Token,
+};
 
 pub mod utils;
 
@@ -20,7 +24,7 @@ impl<C: PixelColor> Ansi<'_, C> {
     }
 }
 
-impl<'a, C: PixelColor> Plugin<'a, C> for Ansi<'a, C> {
+impl<'a, C: PixelColor + From<Rgb888>> Plugin<'a, C> for Ansi<'a, C> {
     fn next_token(
         &mut self,
         mut next_token: impl FnMut() -> Option<crate::Token<'a, C>>,
@@ -38,7 +42,23 @@ impl<'a, C: PixelColor> Plugin<'a, C> for Ansi<'a, C> {
                 Some((0, _)) => match ansi_parser::parse_escape(text) {
                     Ok((string, output)) => {
                         self.carry = Some(Token::Word(string));
-                        Some(Token::EscapeSequence(output))
+                        let new_token = match output {
+                            AnsiSequence::CursorForward(chars) => Token::MoveCursor {
+                                chars: chars as i32,
+                                draw_background: true,
+                            },
+                            AnsiSequence::CursorBackward(chars) => Token::MoveCursor {
+                                chars: -(chars as i32),
+                                draw_background: true,
+                            },
+                            AnsiSequence::SetGraphicsMode(sgr) => try_parse_sgr(&sgr)
+                                .map(|sgr| Token::ChangeTextStyle(sgr.into()))
+                                .or_else(|| self.next_token(next_token))?,
+
+                            _ => self.next_token(next_token)?,
+                        };
+
+                        Some(new_token)
                     }
                     Err(_) => {
                         self.carry = Some(Token::Word(chars.as_str()));

src/rendering/line_iter.rs

@@ -12,10 +12,6 @@ use crate::{
 use az::{SaturatingAs, SaturatingCast};
 use embedded_graphics::{pixelcolor::Rgb888, prelude::PixelColor};
 
-use crate::plugin::ansi::utils::try_parse_sgr;
-use ansi_parser::AnsiSequence;
-use as_slice::AsSlice;
-
 /// Parser to break down a line into primitive elements used by measurement and rendering.
 #[derive(Debug)]
 #[must_use]
@@ -120,7 +116,7 @@ where
                     break 'lookahead;
                 }
 
-                Some(Token::EscapeSequence(_)) => {}
+                Some(Token::ChangeTextStyle(_)) | Some(Token::MoveCursor { .. }) => {}
 
                 _ => break 'lookahead,
             }
@@ -184,15 +180,11 @@ where
                 Some(Token::Whitespace(n, _)) => spaces.consume(n).saturating_as(),
                 Some(Token::Tab) => cursor.next_tab_width().saturating_as(),
 
-                Some(Token::EscapeSequence(AnsiSequence::CursorForward(by))) => {
-                    (by * handler.measure(" ")).saturating_as()
-                }
-
-                Some(Token::EscapeSequence(AnsiSequence::CursorBackward(by))) => {
-                    -(by * handler.measure(" ")).saturating_as::<i32>()
+                Some(Token::MoveCursor { chars, .. }) => {
+                    chars * handler.measure(" ").saturating_as::<i32>()
                 }
 
-                Some(Token::EscapeSequence(_)) => 0,
+                Some(Token::ChangeTextStyle(_)) => 0,
 
                 _ => return false,
             };
@@ -374,46 +366,39 @@ where
                     }
                 }
 
-                Token::EscapeSequence(seq) => {
-                    match seq {
-                        AnsiSequence::SetGraphicsMode(vec) => {
-                            if let Some(sgr) = try_parse_sgr(vec.as_slice()) {
-                                handler.change_text_style(sgr.into())?;
-                            }
-                        }
-
-                        AnsiSequence::CursorForward(n) => {
-                            // Cursor movement can't rely on the text, as it's permitted
-                            // to move the cursor outside of the current line.
-                            // Example:
-                            // (| denotes the cursor, [ and ] are the limits of the line):
-                            // [Some text|    ]
-                            // Cursor forward 2 characters
-                            // [Some text  |  ]
-                            let delta = (n * handler.measure(" ")).saturating_as();
-                            match self.move_cursor(delta) {
-                                Ok(delta) | Err(delta) => {
-                                    handler.whitespace("", 1, delta.saturating_as())?;
-                                }
-                            }
-                        }
-
-                        AnsiSequence::CursorBackward(n) => {
-                            // The above poses an issue with variable-width fonts.
-                            // If cursor movement ignores the variable width, the cursor
-                            // will be placed in positions other than glyph boundaries.
-                            let delta = -(n * handler.measure(" ")).saturating_as::<i32>();
-                            match self.move_cursor(delta) {
-                                Ok(delta) | Err(delta) => {
-                                    handler.move_cursor(delta)?;
-                                    handler.whitespace("", 1, delta.abs().saturating_as())?;
-                                    handler.move_cursor(delta)?;
-                                }
+                // Cursor movement can't rely on the text, as it's permitted
+                // to move the cursor outside of the current line.
+                // Example:
+                // (| denotes the cursor, [ and ] are the limits of the line):
+                // [Some text|    ]
+                // Cursor forward 2 characters
+                // [Some text  |  ]
+                Token::MoveCursor {
+                    chars,
+                    draw_background: true,
+                } => {
+                    let delta = chars * handler.measure(" ").saturating_as::<i32>();
+                    match self.move_cursor(delta) {
+                        Ok(delta) | Err(delta) => {
+                            if chars > 0 {
+                                handler.whitespace("", 1, delta.saturating_as())?;
+                            } else {
+                                handler.move_cursor(delta)?;
+                                handler.whitespace("", 1, delta.abs().saturating_as())?;
+                                handler.move_cursor(delta)?;
                             }
                         }
+                    }
+                }
 
-                        _ => {
-                            // ignore for now
+                Token::MoveCursor {
+                    chars,
+                    draw_background: false,
+                } => {
+                    let delta = chars * handler.measure(" ").saturating_as::<i32>();
+                    match self.move_cursor(delta) {
+                        Ok(delta) | Err(delta) => {
+                            handler.move_cursor(delta)?;
                         }
                     }
                 }