#[path = "review/builder.rs"] pub mod builder; use std::fmt::Debug; use std::path::PathBuf; use std::sync::Arc; use std::sync::Mutex; use anyhow::Result; use termion::event::Key; use ratatui::layout::{Constraint, Position}; use ratatui::style::Stylize; use ratatui::text::Text; use ratatui::{Frame, Viewport}; use radicle::crypto::Signer; use radicle::identity::RepoId; use radicle::patch::{PatchId, Review, Revision}; use radicle::storage::git::Repository; use radicle::storage::{ReadStorage, WriteRepository}; use radicle::Storage; use radicle_tui as tui; use tui::store; use tui::ui::im::widget::{PanesState, TableState, TextViewState, Window}; use tui::ui::im::{Borders, Context, Show, Ui}; use tui::ui::span; use tui::ui::Column; use tui::{Channel, Exit}; use crate::git::HunkDiff; use crate::git::{HunkState, StatefulHunkDiff}; use crate::ui::format; use crate::ui::items::HunkItem; use crate::ui::layout; use super::review::builder::DiffUtil; use self::builder::{Brain, FileReviewBuilder, Hunks}; /// The actions that a user can carry out on a review item. #[derive(Debug, Copy, Clone, PartialEq, Eq)] pub enum ReviewAction { Comment, } #[derive(Clone, Debug, Eq, PartialEq)] pub struct Args(String); #[derive(Clone, Debug, Eq, PartialEq)] pub struct Selection { pub action: ReviewAction, pub hunk: Option, pub args: Option, } pub struct Tui { pub storage: Storage, pub rid: RepoId, pub signer: Box, pub patch: PatchId, pub title: String, pub revision: Revision, pub review: Review, pub hunks: Hunks, } impl Tui { #[allow(clippy::too_many_arguments)] pub fn new( storage: Storage, rid: RepoId, signer: Box, patch: PatchId, title: String, revision: Revision, review: Review, hunks: Hunks, ) -> Self { Self { storage, rid, signer, patch, title, revision, review, hunks, } } pub async fn run(self) -> Result> { let viewport = Viewport::Fullscreen; let channel = Channel::default(); let state = App::new( self.storage, self.rid, self.signer, self.patch, self.title, self.revision, self.review, self.hunks, )?; tui::im(state, viewport, channel).await } } #[derive(Clone, Debug)] pub enum Message<'a> { ShowMain, PanesChanged { state: PanesState }, HunkChanged { state: TableState }, HunkViewChanged { state: DiffViewState }, ShowHelp, HelpChanged { state: TextViewState<'a> }, Comment, Accept, Discard, Quit, } #[derive(Clone, Debug, Eq, PartialEq, Hash)] pub enum AppPage { Main, Help, } #[derive(Clone, Debug)] pub struct DiffViewState { cursor: Position, } pub struct HunkList<'a> { items: Vec>, views: Vec, table: TableState, } impl<'a> HunkList<'a> { pub fn new( items: impl IntoIterator>, views: impl IntoIterator, table: TableState, ) -> Self { Self { items: items.into_iter().collect(), views: views.into_iter().collect(), table, } } pub fn item(&self, index: usize) -> Option<&HunkItem> { self.items.get(index) } pub fn view_state(&self, index: usize) -> Option<&DiffViewState> { self.views.get(index) } pub fn update_view_state(&mut self, index: usize, state: DiffViewState) { if let Some(view) = self.views.get_mut(index) { *view = state; } } pub fn update_table(&mut self, table: TableState) { self.table = table; } pub fn selected(&self) -> Option { self.table.selected() } } #[derive(Clone)] pub struct App<'a> { /// The nodes' storage. storage: Storage, /// The repository to operate on. rid: RepoId, /// Signer of all writes to the storage or repo. signer: Arc>>, /// Patch this review belongs to. patch: PatchId, /// Title of the patch this patch this review belongs to. title: String, /// Revision this review belongs to. revision: Revision, /// All hunks, their view states (cursor position is stored per hunk) /// and the lists' table widget state. hunks: Arc>>, /// Current app page. page: AppPage, /// State of panes widget on the main page. group: PanesState, /// State of text view widget on the help page. help: TextViewState<'a>, } impl<'a> TryFrom for App<'a> { type Error = anyhow::Error; fn try_from(tui: Tui) -> Result { App::new( tui.storage, tui.rid, tui.signer, tui.patch, tui.title, tui.revision, tui.review, tui.hunks, ) } } impl<'a> App<'a> { #[allow(clippy::too_many_arguments)] pub fn new( storage: Storage, rid: RepoId, signer: Box, patch: PatchId, title: String, revision: Revision, review: Review, hunks: Hunks, ) -> Result { let repo = storage.repository(rid)?; let states = hunks .iter() .map(|_| DiffViewState { cursor: Position::new(0, 0), }) .collect::>(); let hunks = hunks .iter() .map(|item| HunkItem::from((&repo, &review, StatefulHunkDiff::from(item)))) .collect::>(); let mut app = App { storage, signer: Arc::new(Mutex::new(signer)), rid, patch, title, revision, hunks: Arc::new(Mutex::new(HunkList::new( hunks, states, TableState::new(Some(0)), ))), page: AppPage::Main, group: PanesState::new(2, Some(0)), help: TextViewState::new(help_text(), Position::default()), }; app.reload_states()?; Ok(app) } #[allow(clippy::borrowed_box)] pub fn accept_current_hunk(&self) -> Result<()> { let repo = self.storage.repository(self.rid).unwrap(); let signer: &Box = &self.signer.lock().unwrap(); if let Some(selected) = self.selected_hunk_idx() { let items = &self.hunks.lock().unwrap().items; let mut brain = Brain::load_or_new(self.patch, &self.revision, repo.raw(), signer)?; let mut last_path: Option<&PathBuf> = None; let mut file: Option = None; for (idx, item) in items.iter().enumerate() { // Get file path. let path = match item.inner.hunk() { HunkDiff::Added { path, .. } => path, HunkDiff::Deleted { path, .. } => path, HunkDiff::Modified { path, .. } => path, HunkDiff::Copied { copied } => &copied.new_path, HunkDiff::Moved { moved } => &moved.new_path, HunkDiff::EofChanged { path, .. } => path, HunkDiff::ModeChanged { path, .. } => path, }; // Set new review builder if hunk belongs to new file. if last_path.is_none() || last_path.unwrap() != path { last_path = Some(path); file = Some(FileReviewBuilder::new(item.inner.hunk())); } if let Some(file) = file.as_mut() { file.set_item(item.inner.hunk()); if idx == selected { let diff = file.item_diff(item.inner.hunk())?; brain.accept(diff, repo.raw())?; } else { file.ignore_item(item.inner.hunk()) } } } } Ok(()) } #[allow(clippy::borrowed_box)] pub fn discard_accepted_hunks(&self) -> Result<()> { let repo = self.repo()?; let signer: &Box = &self.signer.lock().unwrap(); let mut brain = Brain::load_or_new(self.patch, &self.revision, repo.raw(), signer)?; brain.discard_accepted(repo.raw())?; Ok(()) } #[allow(clippy::borrowed_box)] pub fn reload_states(&mut self) -> anyhow::Result<()> { let repo = self.repo()?; let signer: &Box = &self.signer.lock().unwrap(); let items = &mut self.hunks.lock().unwrap().items; let brain = Brain::load_or_new(self.patch, &self.revision, repo.raw(), signer)?; let rejected_hunks = Hunks::new(DiffUtil::new(&repo).rejected_diffs(&brain, &self.revision)?); log::debug!("Reloaded hunk states.."); log::debug!("Rejected hunks: {:?}", rejected_hunks); log::debug!("Requested to reload hunks: {:?}", items); for item in &mut *items { let state = if rejected_hunks.contains(item.inner.hunk()) { HunkState::Rejected } else { HunkState::Accepted }; *item.inner.state_mut() = state; } log::debug!("Reloaded hunks: {:?}", items); Ok(()) } pub fn selected_hunk_idx(&self) -> Option { self.hunks.lock().unwrap().selected() } pub fn repo(&self) -> Result { Ok(self.storage.repository(self.rid)?) } } impl<'a> App<'a> { fn show_hunk_list(&self, ui: &mut Ui>, frame: &mut Frame) { let header = [Column::new(" Hunks ", Constraint::Fill(1))].to_vec(); let columns = [ Column::new("", Constraint::Length(2)), Column::new("", Constraint::Fill(1)), Column::new("", Constraint::Length(15)), ] .to_vec(); let hunks = self.hunks.lock().unwrap(); let mut selected = hunks.selected(); let table = ui.headered_table(frame, &mut selected, &hunks.items, header, columns); if table.changed { ui.send_message(Message::HunkChanged { state: TableState::new(selected), }) } } fn show_hunk(&self, ui: &mut Ui>, frame: &mut Frame) { let hunks = self.hunks.lock().unwrap(); let selected = hunks.selected(); let hunk = selected.and_then(|selected| hunks.item(selected)); if let Some(hunk) = hunk { let empty_text = hunk .hunk_text() .unwrap_or(Text::raw("Nothing to show.").dark_gray()); let mut cursor = selected .and_then(|selected| hunks.view_state(selected)) .map(|state| state.cursor) .unwrap_or_default(); ui.composite(layout::container(), 1, |ui| { ui.columns(frame, hunk.header(), Some(Borders::Top)); if let Some(text) = hunk.hunk_text() { let diff = ui.text_view(frame, text, &mut cursor, Some(Borders::BottomSides)); if diff.changed { ui.send_message(Message::HunkViewChanged { state: DiffViewState { cursor }, }) } } else { ui.centered_text_view(frame, empty_text, Some(Borders::BottomSides)); } }); } } fn show_context_bar(&self, ui: &mut Ui>, frame: &mut Frame) { let hunks = &self.hunks.lock().unwrap().items; let id = format!(" {} ", format::cob(&self.patch)); let title = &self.title; let hunks_total = hunks.len(); let hunks_accepted = hunks .iter() .filter(|hunk| *hunk.inner.state() == HunkState::Accepted) .collect::>() .len(); let accepted_stats = format!(" Accepted {hunks_accepted}/{hunks_total} "); ui.bar( frame, [ Column::new( span::default(" Review ").cyan().dim().reversed(), Constraint::Length(8), ), Column::new( span::default(&id) .style(ui.theme().bar_on_black_style) .magenta(), Constraint::Length(9), ), Column::new( span::default(title) .style(ui.theme().bar_on_black_style) .magenta() .dim(), Constraint::Length(title.chars().count() as u16), ), Column::new( span::default(" ") .into_left_aligned_line() .style(ui.theme().bar_on_black_style), Constraint::Fill(1), ), Column::new( span::default(&accepted_stats) .into_right_aligned_line() .cyan() .dim() .reversed(), Constraint::Length(accepted_stats.chars().count() as u16), ), ] .to_vec(), Some(Borders::None), ); } } impl<'a> Show> for App<'a> { fn show(&self, ctx: &Context>, frame: &mut Frame) -> Result<(), anyhow::Error> { Window::default().show(ctx, |ui| { let mut page_focus = self.group.focus(); match self.page { AppPage::Main => { ui.layout(layout::page(), Some(0), |ui| { let group = ui.panes(layout::list_item(), &mut page_focus, |ui| { self.show_hunk_list(ui, frame); self.show_hunk(ui, frame); }); if group.response.changed { ui.send_message(Message::PanesChanged { state: PanesState::new(self.group.len(), page_focus), }); } self.show_context_bar(ui, frame); ui.shortcuts( frame, &[ ("c", "comment"), ("a", "accept"), ("d", "discard accepted"), ("?", "help"), ("q", "quit"), ], '∙', ); if ui.input_global(|key| key == Key::Char('?')) { ui.send_message(Message::ShowHelp); } if ui.input_global(|key| key == Key::Char('c')) { ui.send_message(Message::Comment); } if ui.input_global(|key| key == Key::Char('a')) { ui.send_message(Message::Accept); } if ui.input_global(|key| key == Key::Char('d')) { ui.send_message(Message::Discard); } }); } AppPage::Help => { ui.panes(layout::page(), &mut page_focus, |ui| { ui.composite(layout::container(), 1, |ui| { let header = [Column::new(" Help ", Constraint::Fill(1))].to_vec(); let mut cursor = self.help.cursor(); ui.columns(frame, header, Some(Borders::Top)); let help = ui.text_view( frame, self.help.text().to_string(), &mut cursor, Some(Borders::BottomSides), ); if help.changed { ui.send_message(Message::HelpChanged { state: TextViewState::new(self.help.text().clone(), cursor), }) } }); self.show_context_bar(ui, frame); ui.shortcuts(frame, &[("?", "close"), ("q", "quit")], '∙'); }); if ui.input_global(|key| key == Key::Char('?')) { ui.send_message(Message::ShowMain); } } } if ui.input_global(|key| key == Key::Char('q')) { ui.send_message(Message::Quit); } }); Ok(()) } } impl<'a> store::Update> for App<'a> { type Return = Selection; fn update(&mut self, message: Message<'a>) -> Option> { log::info!("Received message: {:?}", message); match message { Message::ShowMain => { self.page = AppPage::Main; None } Message::ShowHelp => { self.page = AppPage::Help; None } Message::PanesChanged { state } => { self.group = state; None } Message::HunkChanged { state } => { let mut hunks = self.hunks.lock().unwrap(); hunks.update_table(state); None } Message::HunkViewChanged { state } => { let hunks = &mut self.hunks.lock().unwrap(); if let Some(selected) = hunks.selected() { hunks.update_view_state(selected, state); } None } Message::HelpChanged { state } => { self.help = state; None } Message::Comment => { let hunks = self.hunks.lock().unwrap(); Some(Exit { value: Some(Selection { action: ReviewAction::Comment, hunk: hunks.selected(), args: None, }), }) } Message::Accept => { match self.accept_current_hunk() { Ok(()) => log::info!("Hunk accepted."), Err(err) => log::info!("An error occured while accepting hunk: {}", err), } let _ = self.reload_states(); None } Message::Discard => { match self.discard_accepted_hunks() { Ok(()) => log::info!("Discarded all hunks."), Err(err) => log::info!("An error occured while discarding hunks: {}", err), } let _ = self.reload_states(); None } Message::Quit => Some(Exit { value: None }), } } } fn help_text() -> String { r#"# About A terminal interface for reviewing patch revisions. Starts a new or resumes an existing review for a given revision (default: latest). When the review is done, it needs to be finalized via `rad patch review --accept | --reject `. # Keybindings `←,h` move cursor to the left `↑,k` move cursor one line up `↓,j` move cursor one line down `→,l` move cursor to the right `PageUp` move cursor one page up `PageDown` move cursor one page down `Home` move cursor to the first line `End` move cursor to the last line `Tab` Focus next pane `BackTab` Focus previous pane `?` toogle help `q` quit / cancel ## Specific keybindings `c` comment on hunk `a` accept hunk `d` discard accepted hunks (reject all)"# .into() } #[cfg(test)] mod test { use anyhow::*; use radicle::patch::Cache; use store::Update; use super::*; use crate::test; impl<'a> App<'a> { pub fn hunks(&self) -> Vec { self.hunks.lock().unwrap().items.clone() } } mod fixtures { use anyhow::*; use radicle::cob::cache::NoCache; use radicle::patch::{Cache, PatchMut, Review, ReviewId, Revision, Verdict}; use radicle::prelude::Signer; use radicle::storage::git::cob::DraftStore; use radicle::storage::git::Repository; use crate::cob::patch; use crate::test::setup::NodeWithRepo; use super::builder::ReviewBuilder; use super::App; pub fn app<'a>( node: &NodeWithRepo, patch: PatchMut, ) -> Result> { let draft_store = DraftStore::new(&node.repo.repo, *node.signer.public_key()); let mut drafts = Cache::no_cache(&draft_store)?; let mut draft = drafts.get_mut(&patch.id())?; let (_, revision) = patch.latest(); let (_, review) = draft_review(&node, &mut draft, revision)?; let hunks = ReviewBuilder::new(&node.repo).hunks(revision)?; App::new( node.storage.clone(), node.repo.id, Box::new(node.signer.clone()), *patch.id(), patch.title().to_string(), revision.clone(), review.clone(), hunks, ) } pub fn draft_review<'a>( node: &NodeWithRepo, draft: &'a mut PatchMut, NoCache>, revision: &Revision, ) -> Result<(ReviewId, &'a Review)> { let id = draft.review( revision.id(), Some(Verdict::Reject), None, vec![], &node.node.signer, )?; let (_, review) = patch::find_review(draft, revision, &node.node.signer) .ok_or_else(|| anyhow!("Could not find review."))?; Ok((id, review)) } } #[test] fn app_with_single_hunk_can_be_constructed() -> Result<()> { let alice = test::fixtures::node_with_repo(); let branch = test::fixtures::branch_with_main_emptied(&alice); let mut patches = Cache::no_cache(&alice.repo.repo).unwrap(); let patch = test::fixtures::patch(&alice, &branch, &mut patches)?; let app = fixtures::app(&alice, patch)?; assert_eq!(app.hunks().len(), 1); Ok(()) } #[test] fn app_with_single_file_multiple_hunks_can_be_constructed() -> Result<()> { let alice = test::fixtures::node_with_repo(); let branch = test::fixtures::branch_with_eof_removed(&alice); let mut patches = Cache::no_cache(&alice.repo.repo).unwrap(); let patch = test::fixtures::patch(&alice, &branch, &mut patches)?; let app = fixtures::app(&alice, patch)?; assert_eq!(app.hunks().len(), 2); Ok(()) } #[test] fn first_hunk_is_selected_by_default() -> Result<()> { let alice = test::fixtures::node_with_repo(); let branch = test::fixtures::branch_with_main_emptied(&alice); let mut patches = Cache::no_cache(&alice.repo.repo).unwrap(); let patch = test::fixtures::patch(&alice, &branch, &mut patches)?; let app = fixtures::app(&alice, patch)?; assert_eq!(app.selected_hunk_idx(), Some(0)); Ok(()) } #[test] fn hunks_are_rejected_by_default() -> Result<()> { let alice = test::fixtures::node_with_repo(); let branch = test::fixtures::branch_with_main_deleted_and_file_added(&alice); let mut patches = Cache::no_cache(&alice.repo.repo).unwrap(); let patch = test::fixtures::patch(&alice, &branch, &mut patches)?; let app = fixtures::app(&alice, patch)?; let hunks = app.hunks(); let states = hunks .iter() .map(|item| item.inner.state()) .collect::>(); assert_eq!(states, [&HunkState::Rejected, &HunkState::Rejected,]); Ok(()) } #[test] fn hunk_can_be_selected() -> Result<()> { let alice = test::fixtures::node_with_repo(); let branch = test::fixtures::branch_with_eof_removed(&alice); let mut patches = Cache::no_cache(&alice.repo.repo).unwrap(); let patch = test::fixtures::patch(&alice, &branch, &mut patches)?; let mut app = fixtures::app(&alice, patch)?; app.update(Message::HunkChanged { state: TableState::new(Some(1)), }); assert_eq!(app.selected_hunk_idx(), Some(1)); Ok(()) } #[test] fn single_file_single_hunk_can_be_accepted() -> Result<()> { let alice = test::fixtures::node_with_repo(); let branch = test::fixtures::branch_with_main_emptied(&alice); let mut patches = Cache::no_cache(&alice.repo.repo).unwrap(); let patch = test::fixtures::patch(&alice, &branch, &mut patches)?; let mut app = fixtures::app(&alice, patch)?; app.update(Message::Accept); let hunks = app.hunks(); let state = &hunks.get(0).unwrap().inner.state(); assert_eq!(**state, HunkState::Accepted); Ok(()) } #[test] #[ignore] fn single_file_multiple_hunks_only_first_can_be_accepted() -> Result<()> { let alice = test::fixtures::node_with_repo(); let branch = test::fixtures::branch_with_main_changed(&alice); let mut patches = Cache::no_cache(&alice.repo.repo).unwrap(); let patch = test::fixtures::patch(&alice, &branch, &mut patches)?; let mut app = fixtures::app(&alice, patch)?; app.update(Message::Accept); let hunks = app.hunks(); let states = hunks .iter() .map(|item| item.inner.state()) .collect::>(); assert_eq!(states, [&HunkState::Accepted, &HunkState::Rejected]); Ok(()) } #[test] fn single_file_multiple_hunks_only_last_can_be_accepted() -> Result<()> { let alice = test::fixtures::node_with_repo(); let branch = test::fixtures::branch_with_main_changed(&alice); let mut patches = Cache::no_cache(&alice.repo.repo).unwrap(); let patch = test::fixtures::patch(&alice, &branch, &mut patches)?; let mut app = fixtures::app(&alice, patch)?; app.update(Message::HunkChanged { state: TableState::new(Some(1)), }); app.update(Message::Accept); let hunks = app.hunks(); let states = hunks .iter() .map(|item| item.inner.state()) .collect::>(); assert_eq!(states, [&HunkState::Rejected, &HunkState::Accepted]); Ok(()) } #[test] fn multiple_files_single_hunk_can_be_accepted() -> Result<()> { let alice = test::fixtures::node_with_repo(); let branch = test::fixtures::branch_with_main_deleted_and_file_added(&alice); let mut patches = Cache::no_cache(&alice.repo.repo).unwrap(); let patch = test::fixtures::patch(&alice, &branch, &mut patches)?; let mut app = fixtures::app(&alice, patch)?; app.update(Message::Accept); app.update(Message::HunkChanged { state: TableState::new(Some(1)), }); app.update(Message::Accept); let hunks = app.hunks(); let states = hunks .iter() .map(|item| item.inner.state()) .collect::>(); assert_eq!(states, [&HunkState::Accepted, &HunkState::Accepted]); Ok(()) } }