misc

Author: davidpdrsn

crates/but/src/command/legacy/status/tui/event_polling.rs

@@ -0,0 +1,41 @@
+use std::{convert::Infallible, time::Duration};
+
+use crossterm::event::{self, Event};
+
+/// Trait for abstracting event polling so we can hardcode events in tests.
+pub(super) trait EventPolling {
+    type Error: std::error::Error + Send + Sync + 'static;
+
+    fn poll(self, timeout: Duration) -> Result<impl IntoIterator<Item = Event>, Self::Error>;
+}
+
+/// An [`EventPolling`] implementation that polls events for real using crossterm.
+#[derive(Copy, Clone)]
+pub(super) struct CrosstermEventPolling;
+
+impl EventPolling for CrosstermEventPolling {
+    type Error = std::io::Error;
+
+    fn poll(self, timeout: Duration) -> Result<impl IntoIterator<Item = Event>, Self::Error> {
+        if event::poll(timeout)? {
+            Ok(Some(event::read()?))
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+/// An [`EventPolling`] implementation that never yields events.
+///
+/// This is used for non-interactive runs where touching terminal input can stop the process when
+/// profilers launch the target in a background process group.
+#[derive(Copy, Clone)]
+pub(super) struct NoopEventPolling;
+
+impl EventPolling for NoopEventPolling {
+    type Error = Infallible;
+
+    fn poll(self, _timeout: Duration) -> Result<impl IntoIterator<Item = Event>, Self::Error> {
+        Ok(None)
+    }
+}

crates/but/src/command/legacy/status/tui/fps.rs

@@ -0,0 +1,36 @@
+use std::time::{Duration, Instant};
+
+#[derive(Debug)]
+pub(super) struct FpsCounter {
+    timer: Instant,
+    next_fps: u32,
+    fps: u32,
+}
+
+impl FpsCounter {
+    pub(super) fn new() -> Self {
+        Self {
+            timer: Instant::now(),
+            fps: 0,
+            next_fps: 0,
+        }
+    }
+
+    pub(super) fn frame_finished(&mut self) {
+        self.next_fps += 1;
+    }
+
+    pub(super) fn update(&mut self) -> bool {
+        if self.timer.elapsed() > Duration::from_secs(1) {
+            self.fps = std::mem::take(&mut self.next_fps);
+            self.timer = Instant::now();
+            true
+        } else {
+            false
+        }
+    }
+
+    pub(super) fn fps(&self) -> u32 {
+        self.fps
+    }
+}

crates/but/src/command/legacy/status/tui/key_bind.rs

@@ -29,12 +29,12 @@ pub(super) fn default_key_binds() -> KeyBinds {
                 register_rub_but_api_mode_key_binds(&mut key_binds);
             }
             ModeDiscriminant::InlineReword => {
-                register_global_key_binds(&mut key_binds, Vec::from([mode]));
                 register_inline_reword_mode_key_binds(&mut key_binds);
+                register_quit_key_binds(&mut key_binds, Vec::from([mode]));
             }
             ModeDiscriminant::Command => {
-                register_global_key_binds(&mut key_binds, Vec::from([mode]));
                 register_command_mode_key_binds(&mut key_binds);
+                register_quit_key_binds(&mut key_binds, Vec::from([mode]));
             }
             ModeDiscriminant::Commit => {
                 register_global_key_binds(&mut key_binds, Vec::from([mode]));
@@ -178,6 +178,15 @@ fn register_detail_key_binds(key_binds: &mut KeyBinds) {
         hide_from_hotbar: false,
     });
 
+    key_binds.register(StaticKeyBind {
+        short_description: "command",
+        chord_display: ":",
+        key_matcher: press().code(KeyCode::Char(':')),
+        modes: Vec::from([ModeDiscriminant::Details]),
+        message: Message::Command(CommandMessage::Start),
+        hide_from_hotbar: false,
+    });
+
     key_binds.register(StaticKeyBind {
         short_description: "normal mode",
         chord_display: "ctrl+[",
@@ -467,6 +476,15 @@ fn register_inline_reword_mode_key_binds(key_binds: &mut KeyBinds) {
         message: Message::EnterNormalMode,
         hide_from_hotbar: false,
     });
+
+    key_binds.register(StaticKeyBind {
+        short_description: "normal mode",
+        chord_display: "ctrl+[",
+        key_matcher: press().control().code(KeyCode::Char('[')),
+        modes: Vec::from([ModeDiscriminant::InlineReword]),
+        message: Message::EnterNormalMode,
+        hide_from_hotbar: true,
+    });
 }
 
 fn register_command_mode_key_binds(key_binds: &mut KeyBinds) {
@@ -487,6 +505,15 @@ fn register_command_mode_key_binds(key_binds: &mut KeyBinds) {
         message: Message::EnterNormalMode,
         hide_from_hotbar: false,
     });
+
+    key_binds.register(StaticKeyBind {
+        short_description: "normal mode",
+        chord_display: "ctrl+[",
+        key_matcher: press().control().code(KeyCode::Char('[')),
+        modes: Vec::from([ModeDiscriminant::Command]),
+        message: Message::EnterNormalMode,
+        hide_from_hotbar: true,
+    });
 }
 
 fn register_commit_mode_key_binds(key_binds: &mut KeyBinds) {

crates/but/src/command/legacy/status/tui/mod.rs

@@ -39,6 +39,8 @@ use crate::{
                 confirm::{Confirm, ConfirmMessage},
                 cursor::{Cursor, is_selectable_in_mode},
                 details::{Details, DetailsMessage, DetailsVisibility, RenderNextChunkResult},
+                event_polling::{CrosstermEventPolling, EventPolling, NoopEventPolling},
+                fps::FpsCounter,
                 graph_extension::{ExtensionDirection, extend_connector_spans},
                 highlight::{Highlights, with_highlight},
                 key_bind::{KeyBinds, confirm_key_binds, default_key_binds},
@@ -63,6 +65,8 @@ use super::{
 mod confirm;
 mod cursor;
 mod details;
+mod event_polling;
+mod fps;
 mod graph_extension;
 mod highlight;
 mod key_bind;
@@ -134,44 +138,6 @@ pub(super) async fn render_tui(
     Ok(app.status_lines)
 }
 
-/// Trait for abstracting event polling so we can hardcode events in tests.
-trait EventPolling {
-    type Error: std::error::Error + Send + Sync + 'static;
-
-    fn poll(self, timeout: Duration) -> Result<impl IntoIterator<Item = Event>, Self::Error>;
-}
-
-/// An [`EventPolling`] implementation that polls events for real using crossterm.
-#[derive(Copy, Clone)]
-struct CrosstermEventPolling;
-
-impl EventPolling for CrosstermEventPolling {
-    type Error = std::io::Error;
-
-    fn poll(self, timeout: Duration) -> Result<impl IntoIterator<Item = Event>, Self::Error> {
-        if event::poll(timeout)? {
-            Ok(Some(event::read()?))
-        } else {
-            Ok(None)
-        }
-    }
-}
-
-/// An [`EventPolling`] implementation that never yields events.
-///
-/// This is used for non-interactive runs where touching terminal input can stop the process when
-/// profilers launch the target in a background process group.
-#[derive(Copy, Clone)]
-struct NoopEventPolling;
-
-impl EventPolling for NoopEventPolling {
-    type Error = std::io::Error;
-
-    fn poll(self, _timeout: Duration) -> Result<impl IntoIterator<Item = Event>, Self::Error> {
-        Ok(None)
-    }
-}
-
 #[expect(clippy::too_many_arguments)]
 async fn render_loop<T, E>(
     app: &mut App,
@@ -242,7 +208,11 @@ where
         mode,
     )
     .await?;
+
     render(app, terminal_guard)?;
+
+    app.fps.frame_finished();
+
     Ok(())
 }
 
@@ -332,6 +302,10 @@ where
         app.should_render = true;
     }
 
+    if app.fps.update() {
+        app.should_render = true;
+    }
+
     Ok(())
 }
 
@@ -341,6 +315,7 @@ where
     anyhow::Error: From<<T::Backend as Backend>::Error>,
 {
     if std::mem::take(&mut app.should_render) {
+        let _span = tracing::trace_span!("render").entered();
         terminal_guard.terminal_mut().draw(|frame| {
             app.renders += 1;
             app.render(frame)
@@ -370,6 +345,7 @@ struct App {
     options: TuiLaunchOptions,
     delayed_messages: Vec<Message>,
     incoming_out_of_band_messages: Vec<Rc<Receiver<Message>>>,
+    fps: FpsCounter,
 }
 
 impl App {
@@ -407,6 +383,7 @@ impl App {
             highlight: Default::default(),
             delayed_messages: Default::default(),
             incoming_out_of_band_messages: Default::default(),
+            fps: FpsCounter::new(),
             confirm: None,
             details,
             options,
@@ -1756,10 +1733,6 @@ impl App {
     }
 
     fn handle_enter_command_mode(&mut self) {
-        if !matches!(self.mode, Mode::Normal) {
-            return;
-        }
-
         let mut textarea = TextArea::default();
         textarea.set_cursor_line_style(Style::default());
         textarea.move_cursor(CursorMove::End);
@@ -1855,7 +1828,6 @@ impl App {
         Some(*commit_id)
     }
 
-    #[tracing::instrument(level = Level::TRACE, skip_all)]
     fn render(&self, frame: &mut Frame) {
         let content_layout =
             Layout::vertical([Constraint::Min(1), Constraint::Length(1)]).split(frame.area());
@@ -2514,20 +2486,23 @@ impl App {
     }
 
     fn render_debug(&self, area: Rect, frame: &mut Frame) {
-        let renders = once(ListItem::new("Renders").black().on_blue())
-            .chain(once(ListItem::new(format!("{}", self.renders))));
+        let renders = once(ListItem::new("FPS").black().on_blue()).chain(once(ListItem::new(
+            format!("{} FPS ({} renders)", self.fps.fps(), self.renders),
+        )));
 
         let details_selection = format!("{:#?}", self.details.selection());
         let details_selection = once(ListItem::new("Details selection").black().on_blue()).chain(
             details_selection
                 .lines()
+                .take(100)
                 .map(|line| ListItem::new(line.to_owned())),
         );
 
         let status_selection = format!("{:#?}", self.cursor.selected_line(&self.status_lines));
         let status_selection = once(ListItem::new("Status selection").black().on_blue()).chain(
             status_selection
                 .lines()
+                .take(100)
                 .map(|line| ListItem::new(line.to_owned())),
         );
 

crates/but/src/command/legacy/status/tui/rub_from_detail_view.rs

@@ -14,9 +14,6 @@ pub(super) fn route_operation<'a>(
     source: &'a CommittedHunk,
     target: &'a CliId,
 ) -> Option<Operation<'a>> {
-    // TODO(david): support more operations
-    let todo_ = ();
-
     match target {
         CliId::Commit { commit_id, .. } => Some(Operation::CommittedHunkToCommit {
             source,