feat: make patchset apply action interactive and with feedback

The previous command introduced all the logic to handle the apply of
a patchset into a target kernel tree. However, it lacked any
interactiveness and feedback for the user.

In this sense, add a button "apply" to the "Actions" tab of the
"Patchset Details and Actions" screen, and make it run like the other
actions, i.e., after the user toggles it by hitting (in this case) the
`a` key, the `ENTER` key needs to be hit to actually run the action.

Moreover, implement a new `PopUp` type, named `InfoPopUp`, and use it to
display the result of the patchset apply action.

[Maintainer edits]
- Rephrase commit message
- Switch order of "apply" button with "reviewed-by"
- Implement and use `InfoPopUp` to notify user about result of patchset
  apply action

Signed-off-by: OJarrisonn <[email protected]>
Reviewed-by: David Tadokoro <[email protected]>
Signed-off-by: David Tadokoro <[email protected]>

Author: nahharris

src/app.rs

@@ -1,4 +1,7 @@
-use crate::{log_on_error, ui::popup::PopUp};
+use crate::{
+    log_on_error,
+    ui::popup::{info_popup::InfoPopUp, PopUp},
+};
 use ansi_to_tui::IntoText;
 use color_eyre::eyre::bail;
 use config::Config;
@@ -241,6 +244,7 @@ impl App {
                     patchset_actions: HashMap::from([
                         (PatchsetAction::Bookmark, is_patchset_bookmarked),
                         (PatchsetAction::ReplyWithReviewedBy, false),
+                        (PatchsetAction::Apply, false),
                     ]),
                     reviewed_by,
                     tested_by,
@@ -311,6 +315,28 @@ impl App {
                 .reset_reply_with_reviewed_by_action();
         }
 
+        if let Some(true) = self
+            .details_actions
+            .as_ref()
+            .unwrap()
+            .patchset_actions
+            .get(&PatchsetAction::Apply)
+        {
+            let popup = match self
+                .details_actions
+                .as_ref()
+                .unwrap()
+                .apply_patchset(&self.config)
+            {
+                Ok(msg) => InfoPopUp::generate_info_popup("Patchset Apply Success", &msg),
+                Err(msg) => InfoPopUp::generate_info_popup("Patchset Apply Fail", &msg),
+            };
+
+            self.popup = Some(popup);
+
+            self.details_actions.as_mut().unwrap().toggle_apply_action();
+        }
+
         Ok(())
     }
 

src/app/screens/details_actions.rs

@@ -47,6 +47,7 @@ const LAST_LINE_PADDING: usize = 10;
 pub enum PatchsetAction {
     Bookmark,
     ReplyWithReviewedBy,
+    Apply,
 }
 
 impl DetailsActions {
@@ -142,6 +143,10 @@ impl DetailsActions {
         }
     }
 
+    pub fn toggle_apply_action(&mut self) {
+        self.toggle_action(PatchsetAction::Apply);
+    }
+
     pub fn reset_reply_with_reviewed_by_action(&mut self) {
         self.patches_to_reply = vec![false; self.patches_to_reply.len()];
         self.patchset_actions

src/handler/details_actions.rs

@@ -1,7 +1,7 @@
 use std::time::Duration;
 
 use crate::{
-    app::{logging::Logger, screens::CurrentScreen, App},
+    app::{screens::CurrentScreen, App},
     ui::popup::{help::HelpPopUpBuilder, review_trailers::ReviewTrailersPopUp, PopUp},
     utils,
 };
@@ -67,10 +67,9 @@ pub fn handle_patchset_details<B: Backend>(
             app.set_current_screen(ps_da_clone);
             app.reset_details_actions();
         }
-        KeyCode::Char('a') => match patchset_details_and_actions.apply_patchset(&app.config) {
-            Ok(msg) => Logger::info(msg),
-            Err(msg) => Logger::error(msg),
-        },
+        KeyCode::Char('a') => {
+            patchset_details_and_actions.toggle_apply_action();
+        }
         KeyCode::Char('j') | KeyCode::Down => {
             patchset_details_and_actions.preview_scroll_down(1);
         }

src/ui/details_actions.rs

@@ -134,6 +134,7 @@ fn render_details_and_actions(f: &mut Frame, app: &App, details_chunk: Rect, act
     f.render_widget(patchset_details, details_chunk);
 
     let patchset_actions = &patchset_details_and_actions.patchset_actions;
+    // TODO: Create a function to produce new action lines
     let patchset_actions = vec![
         Line::from(vec![
             if *patchset_actions.get(&PatchsetAction::Bookmark).unwrap() {
@@ -150,6 +151,21 @@ fn render_details_and_actions(f: &mut Frame, app: &App, details_chunk: Rect, act
             ),
             Span::styled("ookmark", Style::default().fg(Color::Cyan)),
         ]),
+        Line::from(vec![
+            if *patchset_actions.get(&PatchsetAction::Apply).unwrap() {
+                Span::styled("[x] ", Style::default().fg(Color::Green))
+            } else {
+                Span::styled("[ ] ", Style::default().fg(Color::Cyan))
+            },
+            Span::styled(
+                "a",
+                Style::default()
+                    .fg(Color::Cyan)
+                    .add_modifier(Modifier::UNDERLINED)
+                    .add_modifier(Modifier::BOLD),
+            ),
+            Span::styled("pply", Style::default().fg(Color::Cyan)),
+        ]),
         Line::from(vec![
             if *patchset_details_and_actions
                 .patches_to_reply

src/ui/popup.rs

@@ -3,6 +3,7 @@ use std::fmt::Debug;
 use ratatui::{crossterm::event::KeyEvent, layout::Rect, Frame};
 
 pub mod help;
+pub mod info_popup;
 pub mod review_trailers;
 
 /// A trait that represents a popup that can be rendered on top of a screen

src/ui/popup/info_popup.rs

@@ -0,0 +1,103 @@
+use ratatui::{
+    crossterm::event::KeyCode,
+    layout::{Alignment, Rect},
+    style::{Color, Modifier, Style},
+    text::Line,
+    widgets::{Block, BorderType, Borders, Clear, Paragraph, Wrap},
+};
+
+use super::PopUp;
+
+#[derive(Debug)]
+pub struct InfoPopUp {
+    title: String,
+    info: String,
+    offset: (u16, u16),
+    max_offset: (u16, u16),
+    dimensions: (u16, u16),
+}
+
+impl InfoPopUp {
+    /// Generate a pop-up with a title and an arbitrary information.
+    pub fn generate_info_popup(title: &str, info: &str) -> Box<dyn PopUp> {
+        let mut lines = 0;
+        let mut columns = 0;
+
+        for line in info.lines() {
+            lines += 1;
+            let line_len = line.len() as u16;
+            if line_len > columns {
+                columns = line_len;
+            }
+        }
+
+        let dimensions = (30, 50); // TODO: Calculate percentage based on the lines and screen size
+
+        Box::new(InfoPopUp {
+            title: title.to_string(),
+            info: info.to_string(),
+            offset: (0, 0),
+            max_offset: (lines, columns),
+            dimensions,
+        })
+    }
+}
+
+impl PopUp for InfoPopUp {
+    fn dimensions(&self) -> (u16, u16) {
+        self.dimensions
+    }
+
+    /// Renders a centered overlaying pop-up with a title and an arbitrary info.
+    fn render(&self, f: &mut ratatui::Frame, chunk: Rect) {
+        let bold_blue = Style::default()
+            .add_modifier(Modifier::BOLD)
+            .fg(Color::Blue);
+        let block = Block::default()
+            .title(self.title.clone())
+            .title_alignment(Alignment::Center)
+            .title_style(bold_blue)
+            .title_bottom(Line::styled("(ESC / q) Close", bold_blue))
+            .borders(Borders::ALL)
+            .border_type(BorderType::Double)
+            .style(Style::default());
+
+        let pop_up = Paragraph::new(self.info.clone())
+            .block(block)
+            .alignment(Alignment::Left)
+            .wrap(Wrap { trim: true })
+            .scroll(self.offset);
+
+        f.render_widget(Clear, chunk);
+        f.render_widget(pop_up, chunk);
+    }
+
+    /// Handles simple one-char width navigation.
+    fn handle(&mut self, key: ratatui::crossterm::event::KeyEvent) -> color_eyre::Result<()> {
+        match key.code {
+            KeyCode::Up | KeyCode::Char('k') => {
+                if self.offset.0 > 0 {
+                    self.offset.0 -= 1;
+                }
+            }
+            KeyCode::Down | KeyCode::Char('j') => {
+                if self.offset.0 < self.max_offset.0 {
+                    self.offset.0 += 1;
+                }
+            }
+            KeyCode::Left | KeyCode::Char('h') => {
+                if self.offset.1 > 0 {
+                    self.offset.1 -= 1;
+                }
+            }
+            KeyCode::Right | KeyCode::Char('l') => {
+                if self.offset.1 < self.max_offset.1 {
+                    self.offset.1 += 1;
+                }
+            }
+            _ => {}
+        }
+
+        Ok(())
+    }
+}