feat: Renderer including Terminal and Panes

Author: ynqa

src/main.rs

@@ -19,15 +19,16 @@ mod editor;
 use editor::Editor;
 mod json;
 use json::JsonProvider;
-mod search;
-use search::{IncrementalSearcher, SearchProvider};
 mod processor;
 use processor::{
     init::ViewInitializer, monitor::ContextMonitor, spinner::SpinnerSpawner, Context, Processor,
     ViewProvider, Visualizer,
 };
 mod prompt;
-use prompt::{PaneIndex, EMPTY_PANE, PANE_SIZE};
+mod render;
+use render::{PaneIndex, Renderer, EMPTY_PANE};
+mod search;
+use search::{IncrementalSearcher, SearchProvider};
 
 /// JSON navigator and interactive filter leveraging jq
 #[derive(Parser)]
@@ -208,6 +209,7 @@ async fn main() -> anyhow::Result<()> {
         },
         100,
         50000,
+        args.no_hint,
     )
     .await?;
 

src/processor.rs

@@ -2,10 +2,10 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use crossterm::event::Event;
-use promkit::{pane::Pane, terminal::Terminal};
+use promkit::pane::Pane;
 use tokio::{sync::Mutex, task::JoinHandle};
 
-use crate::{PaneIndex, EMPTY_PANE, PANE_SIZE};
+use crate::{PaneIndex, Renderer, EMPTY_PANE};
 pub(crate) mod init;
 pub(crate) mod monitor;
 pub(crate) mod spinner;
@@ -63,8 +63,7 @@ impl Processor {
         &self,
         query: String,
         shared_visualizer: Arc<Mutex<impl Visualizer>>,
-        shared_terminal: Arc<Mutex<Terminal>>,
-        shared_panes: Arc<Mutex<[Pane; PANE_SIZE]>>,
+        shared_renderer: Arc<Mutex<Renderer>>,
     ) -> JoinHandle<()> {
         let shared = self.shared.clone();
         tokio::spawn(async move {
@@ -83,14 +82,22 @@ impl Processor {
             };
 
             {
-                let mut panes = shared_panes.lock().await;
+                // TODO: error handling
+                let _ = shared_renderer.lock().await.update_and_draw([
+                    (
+                        PaneIndex::ProcessorGuide,
+                        maybe_guide.unwrap_or(EMPTY_PANE.to_owned()),
+                    ),
+                    (
+                        PaneIndex::Processor,
+                        maybe_resp.unwrap_or(EMPTY_PANE.to_owned()),
+                    ),
+                ]);
+            }
+
+            {
                 let mut shared_state = shared.lock().await;
-                let mut terminal = shared_terminal.lock().await;
-                panes[PaneIndex::ProcessorGuide as usize] =
-                    maybe_guide.unwrap_or(EMPTY_PANE.to_owned());
-                panes[PaneIndex::Processor as usize] = maybe_resp.unwrap_or(EMPTY_PANE.to_owned());
                 shared_state.state = State::Idle;
-                let _ = terminal.draw(&*panes);
             }
         })
     }
@@ -100,8 +107,7 @@ impl Processor {
         shared_visualizer: Arc<Mutex<impl Visualizer>>,
         area: (u16, u16),
         query: String,
-        shared_terminal: Arc<Mutex<Terminal>>,
-        shared_panes: Arc<Mutex<[Pane; PANE_SIZE]>>,
+        shared_renderer: Arc<Mutex<Renderer>>,
     ) {
         {
             let mut shared_state = self.shared.lock().await;
@@ -111,8 +117,7 @@ impl Processor {
             }
         }
 
-        let process_task =
-            self.spawn_process_task(query, shared_visualizer, shared_terminal, shared_panes);
+        let process_task = self.spawn_process_task(query, shared_visualizer, shared_renderer);
 
         {
             let mut shared_state = self.shared.lock().await;
@@ -124,8 +129,7 @@ impl Processor {
         &self,
         shared_visualizer: Arc<Mutex<impl Visualizer>>,
         query: String,
-        shared_terminal: Arc<Mutex<Terminal>>,
-        shared_panes: Arc<Mutex<[Pane; PANE_SIZE]>>,
+        shared_renderer: Arc<Mutex<Renderer>>,
     ) {
         {
             let mut shared_state = self.shared.lock().await;
@@ -134,8 +138,7 @@ impl Processor {
             }
         }
 
-        let process_task =
-            self.spawn_process_task(query, shared_visualizer, shared_terminal, shared_panes);
+        let process_task = self.spawn_process_task(query, shared_visualizer, shared_renderer);
 
         {
             let mut shared_state = self.shared.lock().await;

src/processor/init.rs

@@ -1,10 +1,9 @@
 use std::sync::Arc;
 
-use promkit::{pane::Pane, terminal::Terminal};
 use tokio::sync::Mutex;
 
 use super::{Context, State, ViewProvider, Visualizer};
-use crate::{PaneIndex, PANE_SIZE};
+use crate::{PaneIndex, Renderer};
 
 pub struct ViewInitializer {
     shared: Arc<Mutex<Context>>,
@@ -20,8 +19,7 @@ impl ViewInitializer {
         provider: &'a mut T,
         item: &'static str,
         area: (u16, u16),
-        shared_terminal: Arc<Mutex<Terminal>>,
-        shared_panes: Arc<Mutex<[Pane; PANE_SIZE]>>,
+        shared_renderer: Arc<Mutex<Renderer>>,
     ) -> anyhow::Result<impl Visualizer + 'a> {
         {
             let mut shared_state = self.shared.lock().await;
@@ -35,13 +33,15 @@ impl ViewInitializer {
         let pane = visualizer.create_init_pane(area).await;
 
         {
-            let mut panes = shared_panes.lock().await;
+            // TODO: error handling
+            let _ = shared_renderer
+                .lock()
+                .await
+                .update_and_draw([(PaneIndex::Processor, pane)]);
+        }
+        {
             let mut shared_state = self.shared.lock().await;
-            let mut terminal = shared_terminal.lock().await;
-            panes[PaneIndex::Processor as usize] = pane;
             shared_state.state = State::Idle;
-            // TODO: error handling
-            let _ = terminal.draw(&*panes);
         }
 
         Ok(visualizer)

src/processor/spinner.rs

@@ -1,10 +1,10 @@
 use std::sync::Arc;
 
-use promkit::{pane::Pane, terminal::Terminal};
+use promkit::pane::Pane;
 use tokio::{sync::Mutex, task::JoinHandle, time::Duration};
 
 use super::{Context, State};
-use crate::PaneIndex;
+use crate::{PaneIndex, Renderer};
 
 const LOADING_FRAMES: [&str; 10] = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
@@ -19,8 +19,7 @@ impl SpinnerSpawner {
 
     pub fn spawn_spin_task(
         &self,
-        spin_panes: Arc<Mutex<[Pane]>>,
-        spin_terminal: Arc<Mutex<Terminal>>,
+        shared_renderer: Arc<Mutex<Renderer>>,
         spin_duration: Duration,
     ) -> JoinHandle<()> {
         let shared = self.shared.clone();
@@ -39,18 +38,18 @@ impl SpinnerSpawner {
 
                 frame_index = (frame_index + 1) % LOADING_FRAMES.len();
 
-                let loading_pane = Pane::new(
+                let pane = Pane::new(
                     vec![promkit::grapheme::StyledGraphemes::from(
                         LOADING_FRAMES[frame_index],
                     )],
                     0,
                 );
                 {
-                    let mut panes = spin_panes.lock().await;
-                    let mut terminal = spin_terminal.lock().await;
-                    panes[PaneIndex::Processor as usize] = loading_pane;
                     // TODO: error handling
-                    let _ = terminal.draw(&panes);
+                    let _ = shared_renderer
+                        .lock()
+                        .await
+                        .update_and_draw([(PaneIndex::Processor, pane)]);
                 }
             }
         })