Some kind of refactoring

src/views/render.rs

@@ -1,13 +1,5 @@
-use arc_swap::ArcSwap;
-use parking_lot::Mutex;
-use std::collections::hash_map::DefaultHasher;
-use std::collections::HashMap;
-use std::hash::{Hash, Hasher};
-use std::sync::Arc;
 use std::time::{Duration, Instant};
 
-use rand::rngs::StdRng;
-use rand::SeedableRng;
 use ratatui::layout::{Alignment, Constraint, Layout, Rect};
 use ratatui::style::{Modifier, Style};
 use ratatui::text::{Line, Span};
@@ -16,121 +8,21 @@ use ratatui::Frame;
 
 use crate::app::App;
 use crate::engine::{LinkState, SequencerSnapshot};
-use crate::model::{SourceSpan, StepContext, Value};
+use crate::model::SourceSpan;
 use crate::page::Page;
 use crate::state::{
-    EuclideanField, FlashKind, Modal, PanelFocus, PatternField, SidePanel, StackCache,
+    EuclideanField, FlashKind, Modal, PanelFocus, PatternField, SidePanel,
 };
 use crate::theme;
 use crate::views::highlight::{self, highlight_line, highlight_line_with_runtime};
 use crate::widgets::{
     ConfirmModal, ModalFrame, NavMinimap, NavTile, SampleBrowser, TextInputModal,
 };
-use cagire_forth::Forth;
 
 use super::{
     dict_view, engine_view, help_view, main_view, options_view, patterns_view, title_view,
 };
 
-fn compute_stack_display(
-    lines: &[String],
-    editor: &cagire_ratatui::Editor,
-    cache: &std::cell::RefCell<Option<StackCache>>,
-) -> String {
-    let cursor_line = editor.cursor().0;
-
-    let mut hasher = DefaultHasher::new();
-    for (i, line) in lines.iter().enumerate() {
-        if i > cursor_line {
-            break;
-        }
-        line.hash(&mut hasher);
-    }
-    let lines_hash = hasher.finish();
-
-    if let Some(ref c) = *cache.borrow() {
-        if c.cursor_line == cursor_line && c.lines_hash == lines_hash {
-            return c.result.clone();
-        }
-    }
-
-    let partial: Vec<&str> = lines
-        .iter()
-        .take(cursor_line + 1)
-        .map(|s| s.as_str())
-        .collect();
-    let script = partial.join("\n");
-
-    let result = if script.trim().is_empty() {
-        "Stack: []".to_string()
-    } else {
-        let vars = Arc::new(ArcSwap::from_pointee(HashMap::new()));
-        let dict = Arc::new(Mutex::new(HashMap::new()));
-        let rng = Arc::new(Mutex::new(StdRng::seed_from_u64(42)));
-        let forth = Forth::new(vars, dict, rng);
-
-        let ctx = StepContext {
-            step: 0,
-            beat: 0.0,
-            bank: 0,
-            pattern: 0,
-            tempo: 120.0,
-            phase: 0.0,
-            slot: 0,
-            runs: 0,
-            iter: 0,
-            speed: 1.0,
-            fill: false,
-            nudge_secs: 0.0,
-            cc_access: None,
-            speed_key: "",
-            chain_key: "",
-            #[cfg(feature = "desktop")]
-            mouse_x: 0.5,
-            #[cfg(feature = "desktop")]
-            mouse_y: 0.5,
-            #[cfg(feature = "desktop")]
-            mouse_down: 0.0,
-        };
-
-        match forth.evaluate(&script, &ctx) {
-            Ok(_) => {
-                let stack = forth.stack();
-                let formatted: Vec<String> = stack.iter().map(format_value).collect();
-                format!("Stack: [{}]", formatted.join(" "))
-            }
-            Err(e) => format!("Error: {e}"),
-        }
-    };
-
-    *cache.borrow_mut() = Some(StackCache {
-        cursor_line,
-        lines_hash,
-        result: result.clone(),
-    });
-
-    result
-}
-
-fn format_value(v: &Value) -> String {
-    match v {
-        Value::Int(n, _) => n.to_string(),
-        Value::Float(f, _) => {
-            if f.fract() == 0.0 && f.abs() < 1_000_000.0 {
-                format!("{f:.1}")
-            } else {
-                format!("{f:.4}")
-            }
-        }
-        Value::Str(s, _) => format!("\"{s}\""),
-        Value::Quotation(..) => "[...]".to_string(),
-        Value::CycleList(items) => {
-            let inner: Vec<String> = items.iter().map(format_value).collect();
-            format!("({})", inner.join(" "))
-        }
-    }
-}
-
 fn adjust_spans_for_line(
     spans: &[SourceSpan],
     line_start: usize,
@@ -850,11 +742,13 @@ fn render_modal(frame: &mut Frame, app: &App, snapshot: &SequencerSnapshot, term
                 ]);
                 frame.render_widget(Paragraph::new(hint).alignment(Alignment::Right), hint_area);
             } else if app.editor_ctx.show_stack {
-                let stack_text = compute_stack_display(
-                    text_lines,
-                    &app.editor_ctx.editor,
-                    &app.editor_ctx.stack_cache,
-                );
+                let stack_text = app
+                    .editor_ctx
+                    .stack_cache
+                    .borrow()
+                    .as_ref()
+                    .map(|c| c.result.clone())
+                    .unwrap_or_else(|| "Stack: []".to_string());
                 let hint = Line::from(vec![
                     Span::styled("Esc", key),
                     Span::styled(" save  ", dim),