WIP 75 - Silence compiler warning, move compat test suite file

Silence compiler warning:
macro-expanded `macro_export` macros from the current crate cannot be
referred to by absolute paths
rust-lang/rust#52234

By adding this to lib.rs:

This is a warning for a future error in the compiler. It does not allow
$crate to be used by this macro as_str_slice_test_case! if the macro is
used inside the crate, and by other crates. One solution is just to
require anyone who uses this macro to import the appropriate symbols,
kind of like what you have to do with use `std::fmt::Write as _` before
calling write!

Also, move the compat test suite file to the top level parser_ng folder
instead of being located in the sub-folder "as_str_slice_core". And
rename "core.rs" to "as_str_slice_core.rs" since "core" is used else
where in the code base to refer to the top-level "core" module.

Author: nazmulidris

todo.md

@@ -245,15 +245,15 @@
 - [x] update `md_parser_syn_hi_impl.rs` to use this. provide a new `bool` flag that allows the new
       `_ng` parser active instead of the old one (keep them all in the code for now). there is 1
       function that is shared between the two, so move that to `_ng` for smart code block tests.
-- [ ] add a new test case in `parse_heading_ng()` test cases, and use the markdown constant from the
+- [x] add a new test case in `parse_heading_ng()` test cases, and use the markdown constant from the
       demo examples for the editor, which currently shows up in 2 places (consolidate them into
       one):
   - `get_real_world_content()` in
     `tui/src/tui/md_parser_ng/as_str_slice/compatibility_test_suite.rs`
   - `get_default_content()` in `tui/examples/tui_apps/ex_editor/state.rs`
-- [ ] make quality and compatibility improvments to `md_parse_ng` now that it is attached to the
-      test examples. there is an extra new line at the bottom of the editor for some reason that
-      does not show up with the legacy parser.
+- [x] make quality and compatibility improvments to `md_parse_ng` now that it is attached to the
+      test examples. verify that extra line at the bottom of editor example shows up both for legacy
+      and NG parser
 - [ ] use `cargo bench` in `compatibility_test_suite.rs` to compare the relative performance of both
       legacy and NG parsers
 - [ ] would it be possible to cache the AST returned by `parse_markdown_ng()`? is this a tree

tui/src/core/common/ring_buffer_heap.rs

@@ -16,14 +16,14 @@
  */
 
 //! A fixed-size ring buffer implementation using heap allocation. For stack allocated
-//! version, take a look at [super::RingBufferStack].
+//! version, take a look at [`super::RingBufferStack`].
 
 use std::fmt::Debug;
 
 use super::RingBuffer;
 use crate::{len, Index, Length};
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct RingBufferHeap<T, const N: usize> {
     internal_storage: Vec<Option<T>>,
     head: usize,
@@ -37,7 +37,7 @@ impl<T, const N: usize> Default for RingBufferHeap<T, N> {
 
 impl<T, const N: usize> RingBufferHeap<T, N> {
     pub fn new() -> Self {
-        RingBufferHeap {
+        Self {
             internal_storage: Vec::with_capacity(N),
             head: 0,
             tail: 0,

tui/src/core/stack_alloc_types/sizes.rs

@@ -66,8 +66,8 @@ impl AsRef<str> for InlineStringCow<'_> {
 impl Display for InlineStringCow<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::Borrowed(as_ref_str) => write!(f, "{}", as_ref_str),
-            Self::Owned(as_ref_str) => write!(f, "{}", as_ref_str),
+            Self::Borrowed(as_ref_str) => write!(f, "{as_ref_str}"),
+            Self::Owned(as_ref_str) => write!(f, "{as_ref_str}"),
         }
     }
 }
@@ -82,7 +82,7 @@ pub const DEFAULT_CHAR_STORAGE_SIZE: usize = 4;
 /// [DEFAULT_DOCUMENT_SIZE], it will be [smallvec::SmallVec::spilled] on the heap.
 pub type DocumentStorage = SmallString<[u8; DEFAULT_DOCUMENT_SIZE]>;
 /// 128KB, or approximately 2200 lines of Markdown text (assuming 60 chars per line).
-pub const DEFAULT_DOCUMENT_SIZE: usize = 131072;
+pub const DEFAULT_DOCUMENT_SIZE: usize = 131_072;
 
 // 16KB buffer for reasonable performance on Linux, which typically has a 4KB page size. A
 // page is a fixed sized block of memory, and memory is managed in terms of pages. It is

tui/src/core/tui_core/color_wheel/color_wheel_impl.rs

@@ -191,9 +191,9 @@ impl ColorWheel {
                 self.gradient_length_kind = GradientLengthKind::Lolcat(builder.seed);
             }
 
-            ColorWheelConfig::Rgb(stops, _, _) => {
+            ColorWheelConfig::Rgb(color_stops, _, _) => {
                 // Generate new gradient.
-                let new_gradient = generate_truecolor_gradient(stops, steps);
+                let new_gradient = generate_truecolor_gradient(color_stops, steps);
                 self.gradient_length_kind =
                     GradientLengthKind::ColorWheel(new_gradient.len());
                 self.gradient_kind = GradientKind::ColorWheel(new_gradient);
@@ -454,11 +454,11 @@ impl ColorWheel {
             pub fn gen_style_fg_bg_color_for(
                 maybe_style: Option<TuiStyle>,
                 next_fg_color: Option<TuiColor>,
-                next_bg_color: Option<TuiColor>,
+                next_background_color: Option<TuiColor>,
             ) -> TuiStyle {
                 let mut it = TuiStyle {
                     color_fg: next_fg_color,
-                    color_bg: next_bg_color,
+                    color_bg: next_background_color,
                     ..Default::default()
                 };
                 it += &maybe_style;

tui/src/core/tui_core/color_wheel/lolcat_impl.rs

@@ -40,13 +40,14 @@ impl Default for Lolcat {
 
 impl Debug for Lolcat {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        return write! { f,
-          "lolcat: [{}, {}, {}, {}]",
-          pretty_print_f64(*self.color_wheel_control.seed),
-          pretty_print_f64(*self.color_wheel_control.spread),
-          pretty_print_f64(*self.color_wheel_control.frequency),
-          self.color_wheel_control.color_change_speed
-        };
+        return write!(
+            f,
+            "lolcat: [{}, {}, {}, {}]",
+            pretty_print_f64(*self.color_wheel_control.seed),
+            pretty_print_f64(*self.color_wheel_control.spread),
+            pretty_print_f64(*self.color_wheel_control.frequency),
+            self.color_wheel_control.color_change_speed
+        );
 
         /// More info: <https://stackoverflow.com/questions/63214346/how-to-truncate-f64-to-2-decimal-places>
         fn pretty_print_f64(before: f64) -> f64 { f64::trunc(before * 100.0) / 100.0 }

tui/src/tui/md_parser_ng/as_str_slice/core.rs renamed to tui/src/tui/md_parser_ng/as_str_slice/as_str_slice_core.rs

@@ -298,84 +298,6 @@ where
     pub current_taken: CharacterLength,
 }
 
-/// Macro for quickly creating an [`AsStrSlice`] test instance from one or more string
-/// literals.
-///
-/// This macro is intended for use in tests and examples, allowing you to easily construct
-/// an [`AsStrSlice`] from a list of string slices. It automatically wraps each string in
-/// a [`GCString`] and creates an array, which is then passed to [`AsStrSlice::from()`].
-///
-/// You can also specify an optional character length limit using the `limit:` syntax,
-/// which will call [`AsStrSlice::with_limit()`] instead.
-///
-/// # Examples
-///
-/// Basic usage with multiple lines:
-/// ```
-/// use r3bl_tui::{as_str_slice_test_case, AsStrSlice};
-/// as_str_slice_test_case!(slice, "hello", "world");
-/// assert_eq!(slice.to_inline_string(), "hello\nworld\n");
-/// ```
-///
-/// Single line:
-/// ```
-/// use r3bl_tui::{as_str_slice_test_case, AsStrSlice};
-/// as_str_slice_test_case!(slice, "single line");
-/// assert_eq!(slice.to_inline_string(), "single line");
-/// ```
-///
-/// With a character length limit:
-/// ```
-/// use r3bl_tui::{as_str_slice_test_case, AsStrSlice};
-/// as_str_slice_test_case!(slice, limit: 5, "abcdef", "ghijk");
-/// assert_eq!(slice.to_inline_string(), "abcde");
-/// ```
-///
-/// Empty lines are preserved:
-/// ```
-/// use r3bl_tui::{as_str_slice_test_case, AsStrSlice};
-/// as_str_slice_test_case!(slice, "", "foo", "");
-/// assert_eq!(slice.to_inline_string(), "\nfoo\n\n");
-/// ```
-#[macro_export]
-macro_rules! as_str_slice_test_case {
-    ($var_name:ident, $($string_expr:expr),+ $(,)?) => {
-        #[allow(unused_variables)]
-        let _input_array = [$($crate::GCString::new($string_expr)),+];
-        let $var_name = $crate::AsStrSlice::from(&_input_array);
-    };
-    ($var_name:ident, limit: $max_len:expr, $($string_expr:expr),+ $(,)?) => {
-        #[allow(unused_variables)]
-        let _input_array = [$($crate::GCString::new($string_expr)),+];
-        let $var_name = $crate::AsStrSlice::with_limit(&_input_array, $crate::idx(0), $crate::idx(0), Some($crate::len($max_len)));
-    };
-}
-
-#[cfg(test)]
-mod tests_as_str_slice_test_case {
-    use crate::{as_str_slice_test_case, assert_eq2};
-
-    #[test]
-    fn test_as_str_slice_creation() {
-        // Single string.
-        as_str_slice_test_case!(input, "@title: Something");
-        assert_eq2!(input.lines.len(), 1);
-        assert_eq2!(input.lines[0].as_ref(), "@title: Something");
-
-        // Multiple strings.
-        as_str_slice_test_case!(input, "@title: Something", "more content", "even more");
-        assert_eq2!(input.lines.len(), 3);
-        assert_eq2!(input.lines[0].as_ref(), "@title: Something");
-        assert_eq2!(input.lines[1].as_ref(), "more content");
-        assert_eq2!(input.lines[2].as_ref(), "even more");
-
-        // With trailing comma (optional).
-        as_str_slice_test_case!(input, "@title: Something",);
-        assert_eq2!(input.lines.len(), 1);
-        assert_eq2!(input.lines[0].as_ref(), "@title: Something");
-    }
-}
-
 /// Extension trait for getting the character length of string-like types.
 ///
 /// This trait provides a unified interface for obtaining the character count

tui/src/tui/md_parser_ng/as_str_slice/compatibility.rs

@@ -121,8 +121,7 @@ pub fn convert_into_code_block_lines<'input>(
 /// lines.
 #[cfg(test)]
 mod tests_write_to_byte_cache_compat_behavior {
-    use super::*;
-    use crate::{as_str_slice_test_case, GCString, ParserByteCache};
+    use crate::{as_str_slice_test_case, AsStrSlice, GCString, ParserByteCache};
 
     #[test]
     fn test_empty_string() {

tui/src/tui/md_parser_ng/as_str_slice/mod.rs

@@ -89,20 +89,29 @@
 //! documentation on the [`AsStrSlice`] struct.**
 
 // Attach.
+#[rustfmt::skip]
 pub mod compatibility;
-#[cfg(test)]
-pub mod compatibility_test_suite;
-pub mod core;
+#[rustfmt::skip]
+pub mod as_str_slice_core;
+#[rustfmt::skip]
 pub mod iterators;
+#[rustfmt::skip]
 pub mod operations;
+#[rustfmt::skip]
 pub mod position;
+#[rustfmt::skip]
 pub mod traits;
 
 // Re-export.
-pub use core::*;
-
+#[rustfmt::skip] 
+pub use as_str_slice_core::*;
+#[rustfmt::skip] 
 pub use compatibility::*;
+#[rustfmt::skip] 
 pub use iterators::*;
+#[rustfmt::skip] 
 pub use operations::*;
+#[rustfmt::skip] 
 pub use position::*;
+#[rustfmt::skip] 
 pub use traits::*;

tui/src/tui/md_parser_ng/as_str_slice/operations/search_and_split.rs

@@ -117,7 +117,7 @@ impl<'a> AsStrSlice<'a> {
     /// ## Examples
     ///
     /// ```rust
-    /// # use r3bl_tui::{as_str_slice_test_case, len};
+    /// # use r3bl_tui::{GCString, AsStrSlice, as_str_slice_test_case, len};
     /// // ✅ Good: Single-line processing
     /// as_str_slice_test_case!(input, "Hello, World!");
     /// let result = input.skip_take_in_current_line(7, 5); // Skip "Hello, ", take "World"
@@ -192,8 +192,7 @@ impl<'a> AsStrSlice<'a> {
 mod tests_is_empty {
     use nom::Input as _;
 
-    use super::*;
-    use crate::{as_str_slice_test_case, assert_eq2, idx, len, GCString};
+    use crate::{as_str_slice_test_case, assert_eq2, idx, len, AsStrSlice, GCString};
 
     #[test]
     fn test_is_empty_with_max_len_zero() {

tui/src/tui/md_parser_ng/as_str_slice/operations/trim_whitespace.rs

@@ -116,8 +116,7 @@ impl<'a> AsStrSlice<'a> {
 mod tests_trim_whitespace_chars_start_current_line {
     use nom::Input as _;
 
-    use super::*;
-    use crate::{as_str_slice_test_case, assert_eq2, idx, len, GCString};
+    use crate::{as_str_slice_test_case, assert_eq2, idx, len, AsStrSlice, GCString};
 
     #[test]
     fn test_no_whitespace_to_trim() {