[tui] Editor component - remove content comparison from cache implemenation

Author: nazmulidris

CHANGELOG.md

@@ -288,10 +288,13 @@
 <a id="markdown-next-release" name="next-release"></a>
 
 - Fixed:
-  - Fix the custom MD parser so that it correctly parses plain text. Also disable the
-    syntect highlighter for the editor by default and just use the custom MD parser. For
-    files that are not Markdown, we will probably need to enable syntect in the future
-    since it is not covered by the custom MD parser & highlighter combo.
+  - Fix the custom MD parser so that it correctly parses plain text.
+
+- Changed:
+  - In the editor component - disable the syntect highlighter for the editor by default
+    and just use the custom MD parser. For files that are not Markdown, we will probably
+    need to enable syntect in the future since it is not covered by the custom MD parser &
+    highlighter combo.
 
 - Added:
   - Add undo, redo support for the editor component.
@@ -303,6 +306,11 @@
     terminal emulator. Also added conversion function
     `convert_tui_color_into_r3bl_ansi_color()` to convert from `TuiColor` to
     `r3bl_ansi_term::Color`.
+  - In editor component, add support for caching rendered output of content. When the
+    content changes, or the viewport size or window size change, the cache is invalidated.
+    This is useful for performance reasons. It also leverages the undo/redo system for
+    cache invalidation (which makes it fast to invalidate the render ops cache w/out
+    having to do a content comparison to detect changes).
 
 - Changed:
   - Redux is no longer used in order to propagate state transitions from async middleware

tui/src/tui/editor/editor_buffer/editor_buffer_struct.rs

@@ -170,7 +170,7 @@ use crate::*;
 pub struct EditorBuffer {
     editor_content: EditorContent,
     pub(crate) history: EditorBufferHistory,
-    pub render_cache: RenderCache,
+    pub render_cache: HashMap<String, RenderOps>,
 }
 
 #[derive(Clone, PartialEq, Serialize, Deserialize, GetSize, Default)]
@@ -188,12 +188,6 @@ pub struct EditorBufferHistory {
     current_index: isize,
 }
 
-#[derive(Clone, PartialEq, Serialize, Deserialize, Default, GetSize)]
-pub struct RenderCache {
-    cache_map: HashMap<String, RenderOps>,
-    editor_content: EditorContent,
-}
-
 impl Default for EditorBufferHistory {
     fn default() -> Self {
         Self {
@@ -211,6 +205,9 @@ pub mod history {
     }
 
     pub fn push(editor_buffer: &mut EditorBuffer) {
+        // Invalidate the content cache, since the content just changed.
+        cache::clear(editor_buffer);
+
         let content_copy = editor_buffer.editor_content.clone();
 
         // Delete the history from the current version index to the end.
@@ -233,6 +230,9 @@ pub mod history {
     }
 
     pub fn undo(editor_buffer: &mut EditorBuffer) {
+        // Invalidate the content cache, since the content just changed.
+        cache::clear(editor_buffer);
+
         let retain_caret_position = editor_buffer.editor_content.caret_display_position;
         if let Some(content) = editor_buffer.history.previous_content() {
             editor_buffer.editor_content = content;
@@ -245,6 +245,9 @@ pub mod history {
     }
 
     pub fn redo(editor_buffer: &mut EditorBuffer) {
+        // Invalidate the content cache, since the content just changed.
+        cache::clear(editor_buffer);
+
         if let Some(content) = editor_buffer.history.next_content() {
             editor_buffer.editor_content = content;
         }
@@ -546,47 +549,49 @@ mod constructor {
 pub mod cache {
     use super::*;
 
-    impl EditorBuffer {
-        /// Render the content of the editor buffer to the screen from the cache if the content
-        /// has not been modified.
-        ///
-        /// The cache miss occurs if
-        /// - Scroll Offset changes
-        /// - Window size changes
-        /// - Content of the editor changes
-        pub fn render_content_from_cache(
-            &mut self,
-            key: String,
-            render_args: &RenderArgs<'_>,
-            render_ops: &mut RenderOps,
-        ) {
-            if let Some(cached_output) = self.render_cache.cache_map.get(&key) {
-                if &self.render_cache.editor_content.lines == &self.editor_content.lines {
-                    // Cache hit
-                    *render_ops = cached_output.clone();
-                } else {
-                    // Content has been modified.
-                    self.handle_cache_miss(key, render_args, render_ops);
-                }
-            } else {
-                // Scroll Offset or Window size has been modified.
-                self.handle_cache_miss(key, render_args, render_ops);
-            }
-        }
+    pub fn clear(editor_buffer: &mut EditorBuffer) { editor_buffer.render_cache.clear(); }
 
-        /// When the cache miss occurs, the entire buffer needs to be re-rendered.
-        /// Cache Map is cleared and the new render ops are stored in the cache.
-        fn handle_cache_miss(
-            &mut self,
-            key: String,
-            render_args: &RenderArgs<'_>,
-            render_ops: &mut RenderOps,
-        ) {
-            self.render_cache.cache_map.clear();
-            EditorEngineApi::render_content(render_args, render_ops);
-            self.render_cache.editor_content = self.editor_content.clone();
-            self.render_cache.cache_map.insert(key, render_ops.clone());
-        }
+    /// Cache key is combination of scroll_offset and window_size.
+    fn generate_key(editor_buffer: &EditorBuffer, window_size: Size) -> String {
+        format!("{}{}", editor_buffer.get_scroll_offset(), window_size,)
+    }
+
+    /// Render the content of the editor buffer to the screen from the cache if the content
+    /// has not been modified.
+    ///
+    /// The cache miss occurs if
+    /// - Scroll Offset changes
+    /// - Window size changes
+    /// - Content of the editor changes
+    pub fn render_content(
+        editor_buffer: &mut EditorBuffer,
+        editor_engine: &mut EditorEngine,
+        window_size: Size,
+        has_focus: &mut HasFocus,
+        render_ops: &mut RenderOps,
+    ) {
+        let key = generate_key(editor_buffer, window_size);
+        if let Some(cached_output) = editor_buffer.render_cache.get(&key) {
+            // Cache hit
+            *render_ops = cached_output.clone();
+            return;
+        }
+
+        // Cache miss, due to either:
+        // - Content has been modified.
+        // - Scroll Offset or Window size has been modified.
+        editor_buffer.render_cache.clear();
+        let render_args = RenderArgs {
+            editor_engine,
+            editor_buffer,
+            has_focus,
+        };
+
+        // Re-render content, generate & write to render_ops.
+        EditorEngineApi::render_content(&render_args, render_ops);
+
+        // Snapshot the render_ops in the cache.
+        editor_buffer.render_cache.insert(key, render_ops.clone());
     }
 }
 pub enum CaretKind {

tui/src/tui/editor/editor_engine/editor_engine_api.rs

@@ -121,31 +121,39 @@ impl EditorEngineApi {
         throws_with_return!({
             editor_engine.current_box = current_box.into();
 
-            // Create reusable args for render functions.
-            let render_args = RenderArgs {
-                editor_buffer: &editor_buffer.clone(),
-                editor_engine,
-                has_focus,
-            };
-
             if editor_buffer.is_empty() {
-                EditorEngineApi::render_empty_state(&render_args)
+                EditorEngineApi::render_empty_state(RenderArgs {
+                    editor_buffer,
+                    editor_engine,
+                    has_focus,
+                })
             } else {
                 let mut render_ops = render_ops!();
-                // Cache key is combination of scroll_offset and window_size.
-                let cache_key = format!(
-                    "{}{}",
-                    editor_buffer.get_scroll_offset().to_string(),
-                    window_size.to_string()
+
+                cache::render_content(
+                    editor_buffer,
+                    editor_engine,
+                    window_size,
+                    has_focus,
+                    &mut render_ops,
                 );
 
-                editor_buffer.render_content_from_cache(
-                    cache_key,
-                    &render_args,
+                EditorEngineApi::render_selection(
+                    RenderArgs {
+                        editor_buffer,
+                        editor_engine,
+                        has_focus,
+                    },
+                    &mut render_ops,
+                );
+                EditorEngineApi::render_caret(
+                    RenderArgs {
+                        editor_buffer,
+                        editor_engine,
+                        has_focus,
+                    },
                     &mut render_ops,
                 );
-                EditorEngineApi::render_selection(&render_args, &mut render_ops);
-                EditorEngineApi::render_caret(&render_args, &mut render_ops);
 
                 let mut render_pipeline = render_pipeline!();
                 render_pipeline.push(ZOrder::Normal, render_ops);
@@ -205,7 +213,7 @@ impl EditorEngineApi {
     }
 
     // BOOKM: Render selection
-    fn render_selection(render_args: &RenderArgs<'_>, render_ops: &mut RenderOps) {
+    fn render_selection(render_args: RenderArgs<'_>, render_ops: &mut RenderOps) {
         let RenderArgs {
             editor_buffer,
             editor_engine,
@@ -292,7 +300,7 @@ impl EditorEngineApi {
         }
     }
 
-    fn render_caret(render_args: &RenderArgs<'_>, render_ops: &mut RenderOps) {
+    fn render_caret(render_args: RenderArgs<'_>, render_ops: &mut RenderOps) {
         let RenderArgs {
             editor_buffer,
             editor_engine,
@@ -327,7 +335,7 @@ impl EditorEngineApi {
         }
     }
 
-    pub fn render_empty_state(render_args: &RenderArgs<'_>) -> RenderPipeline {
+    pub fn render_empty_state(render_args: RenderArgs<'_>) -> RenderPipeline {
         let RenderArgs {
             has_focus,
             editor_engine,