patch/list: Rework search — radicle-tui

radicle-tui

rad:z39mP9rQAaGmERfUMPULfPUi473tY

Radicle terminal user interface

patch/list: Rework search

Merged did:key:z6MkgFq6...nBGz opened 4 months ago

Activity Changes +1844 -1750

9 files changed +1844 -1750 1592a0d7 → de8ae91f

modified bin/cob.rs

@@ -1,2 +1,15 @@

 use radicle::node::device::Device;
 use radicle::patch::{Patch, Review, ReviewId, Revision};
 pub mod issue;
 pub mod patch;
 pub fn find_review<'a, G>(
     patch: &'a Patch,
     revision: &Revision,
     signer: &Device<G>,
 ) -> Option<(ReviewId, &'a Review)> {
     patch
         .reviews_of(revision.id())
         .find(|(_, review)| review.author().public_key() == signer.public_key())
         .map(|(id, review)| (*id, review))
 }

deleted bin/cob/patch.rs

@@ -1,146 +0,0 @@

 use std::fmt;
 use std::fmt::Write as _;
 use anyhow::Result;
 use radicle::cob::patch::{Patch, PatchId};
 use radicle::identity::Did;
 use radicle::node::device::Device;
 use radicle::patch::cache::Patches;
 use radicle::patch::{Review, ReviewId, Revision, Status};
 use radicle::storage::git::Repository;
 use radicle::Profile;
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Filter {
     status: Option<Status>,
     authored: bool,
     authors: Vec<Did>,
 }
 impl Default for Filter {
     fn default() -> Self {
         Self {
             status: Some(Status::default()),
             authored: false,
             authors: vec![],
         }
     }
 }
 impl Filter {
     pub fn with_status(mut self, status: Option<Status>) -> Self {
         self.status = status;
         self
     }
     pub fn with_authored(mut self, authored: bool) -> Self {
         self.authored = authored;
         self
     }
     pub fn with_author(mut self, author: Did) -> Self {
         self.authors.push(author);
         self
     }
 }
 impl fmt::Display for Filter {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if let Some(state) = &self.status {
             write!(f, "is:{state}")?;
             f.write_char(' ')?;
         }
         if self.authored {
             f.write_str("is:authored")?;
             f.write_char(' ')?;
         }
         if !self.authors.is_empty() {
             f.write_str("authors:")?;
             f.write_char('[')?;
             let mut authors = self.authors.iter().peekable();
             while let Some(author) = authors.next() {
                 f.write_str(&author.encode())?;
                 if authors.peek().is_some() {
                     f.write_char(',')?;
                 }
             }
             f.write_char(']')?;
         }
         Ok(())
     }
 }
 pub fn all(profile: &Profile, repository: &Repository) -> Result<Vec<(PatchId, Patch)>> {
     let cache = profile.patches(repository)?;
     let patches = cache.list()?;
     Ok(patches.flatten().collect())
 }
 pub fn find(profile: &Profile, repository: &Repository, id: &PatchId) -> Result<Option<Patch>> {
     let cache = profile.patches(repository)?;
     Ok(cache.get(id)?)
 }
 pub fn find_review<'a, G>(
     patch: &'a Patch,
     revision: &Revision,
     signer: &Device<G>,
 ) -> Option<(ReviewId, &'a Review)> {
     patch
         .reviews_of(revision.id())
         .find(|(_, review)| review.author().public_key() == signer.public_key())
         .map(|(id, review)| (*id, review))
 }
 #[cfg(test)]
 mod tests {
     use std::str::FromStr;
     use anyhow::Result;
     use radicle::patch;
     use super::*;
     #[test]
     fn patch_filter_display_with_status_should_succeed() -> Result<()> {
         let actual = Filter::default().with_status(Some(patch::Status::Open));
         assert_eq!(String::from("is:open "), actual.to_string());
         Ok(())
     }
     #[test]
     fn patch_filter_display_with_status_and_authored_should_succeed() -> Result<()> {
         let actual = Filter::default()
             .with_status(Some(patch::Status::Open))
             .with_authored(true);
         assert_eq!(String::from("is:open is:authored "), actual.to_string());
         Ok(())
     }
     #[test]
     fn patch_filter_display_with_status_and_author_should_succeed() -> Result<()> {
         let actual = Filter::default()
             .with_status(Some(patch::Status::Open))
             .with_author(Did::from_str(
                 "did:key:z6MkswQE8gwZw924amKatxnNCXA55BMupMmRg7LvJuim2C1V",
             )?);
         assert_eq!(
             String::from(
                 "is:open authors:[did:key:z6MkswQE8gwZw924amKatxnNCXA55BMupMmRg7LvJuim2C1V]"
             ),
             actual.to_string()
         );
         Ok(())
     }
 }

modified bin/commands/patch.rs

@@ -1,5 +1,3 @@

 #[path = "patch/common.rs"]
 mod common;
 #[path = "patch/list.rs"]
 mod list;
 #[path = "patch/review.rs"]

@@ -12,15 +10,17 @@ use anyhow::anyhow;

 use radicle::cob::ObjectId;
 use radicle::identity::RepoId;
 use radicle::patch::{Patch, Revision, RevisionId, Status};
 use radicle::prelude::Did;
 use radicle::storage::git::Repository;
 use radicle_cli::git::Rev;
 use radicle_cli::terminal;
 use radicle_cli::terminal::args;
 use radicle_cli::terminal::args::{string, Args, Error, Help};
 use crate::cob::patch;
 use crate::commands::tui_patch::common::PatchOperation;
 use crate::terminal;
 use crate::terminal::Quiet;
 use crate::ui::items::filter::DidFilter;
 use crate::ui::items::patch::filter::PatchFilter;
 pub const HELP: Help = Help {
     name: "patch",

@@ -46,8 +46,8 @@ List options

 Other options
     --no-forward        Don't forward command to `rad` (default: true)
     --help              Print help (enables forwarding)
     --no-forward            Don't forward command to `rad` (default: true)
     --help                  Print help (enables forwarding)
 "#,
 };

@@ -75,7 +75,7 @@ pub enum OperationName {

 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct ListOptions {
     filter: patch::Filter,
     filter: ListFilter,
     json: bool,
 }

@@ -111,6 +111,68 @@ impl ReviewOptions {

     }
 }
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ListFilter {
     state: Option<Status>,
     authored: bool,
     authors: Vec<Did>,
 }
 impl Default for ListFilter {
     fn default() -> Self {
         Self {
             state: Some(Status::Open),
             authored: false,
             authors: vec![],
         }
     }
 }
 impl ListFilter {
     pub fn is_default(&self) -> bool {
         *self == ListFilter::default()
     }
     pub fn with_state(mut self, status: Option<Status>) -> Self {
         self.state = status;
         self
     }
     pub fn with_authored(mut self, authored: bool) -> Self {
         self.authored = authored;
         self
     }
     pub fn with_author(mut self, author: Did) -> Self {
         self.authors.push(author);
         self
     }
 }
 #[allow(clippy::from_over_into)]
 impl Into<PatchFilter> for (Did, ListFilter) {
     fn into(self) -> PatchFilter {
         let (me, mut filter) = self;
         let mut and = filter
             .state
             .map(|s| vec![PatchFilter::State(s)])
             .unwrap_or(vec![]);
         let mut dids = filter.authored.then_some(vec![me]).unwrap_or_default();
         dids.append(&mut filter.authors);
         if dids.len() == 1 {
             and.push(PatchFilter::Author(DidFilter::Single(
                 *dids.first().unwrap(),
             )));
         } else if dids.len() > 1 {
             and.push(PatchFilter::Author(DidFilter::Or(dids)));
         }
         PatchFilter::And(and)
     }
 }
 impl Args for Options {
     fn from_args(args: Vec<OsString>) -> anyhow::Result<(Self, Vec<OsString>)> {
         use lexopt::prelude::*;

@@ -144,37 +206,35 @@ impl Args for Options {

                 }
                 Long("all") if op == OperationName::List => {
                     list_opts.filter = list_opts.filter.with_status(None);
                     list_opts.filter = list_opts.filter.with_state(None);
                 }
                 Long("draft") if op == OperationName::List => {
                     list_opts.filter = list_opts.filter.with_status(Some(Status::Draft));
                     list_opts.filter = list_opts.filter.with_state(Some(Status::Draft));
                 }
                 Long("archived") if op == OperationName::List => {
                     list_opts.filter = list_opts.filter.with_status(Some(Status::Archived));
                     list_opts.filter = list_opts.filter.with_state(Some(Status::Archived));
                 }
                 Long("merged") if op == OperationName::List => {
                     list_opts.filter = list_opts.filter.with_status(Some(Status::Merged));
                     list_opts.filter = list_opts.filter.with_state(Some(Status::Merged));
                 }
                 Long("open") if op == OperationName::List => {
                     list_opts.filter = list_opts.filter.with_status(Some(Status::Open));
                     list_opts.filter = list_opts.filter.with_state(Some(Status::Open));
                 }
                 Long("authored") if op == OperationName::List => {
                     list_opts.filter = list_opts.filter.with_authored(true);
                 }
                 Long("author") if op == OperationName::List => {
                     list_opts.filter = list_opts
                         .filter
                         .with_author(terminal::args::did(&parser.value()?)?);
                     list_opts.filter = list_opts.filter.with_author(args::did(&parser.value()?)?);
                 }
                 Long("repo") => {
                     let val = parser.value()?;
                     let rid = terminal::args::rid(&val)?;
                     let rid = args::rid(&val)?;
                     repo = Some(rid);
                 }
                 Long("revision") => {
                     let val = parser.value()?;
                     let rev_id = terminal::args::rev(&val)?;
                     let rev_id = args::rev(&val)?;
                     revision_id = Some(rev_id);
                 }

@@ -236,7 +296,8 @@ impl Args for Options {

 }
 #[tokio::main]
 pub async fn run(options: Options, ctx: impl terminal::Context) -> anyhow::Result<()> {
 pub async fn run(options: Options, ctx: impl radicle_cli::terminal::Context) -> anyhow::Result<()> {
     use crate::tui_patch::list::PatchOperation;
     use radicle::storage::ReadStorage;
     let (_, rid) = radicle::rad::cwd()

@@ -267,21 +328,21 @@ pub async fn run(options: Options, ctx: impl terminal::Context) -> anyhow::Resul

                 if let Some(operation) = selection.operation.clone() {
                     match operation {
                         PatchOperation::Show { id } => {
                             crate::terminal::run_rad(
                             terminal::run_rad(
                                 Some("patch"),
                                 &["show".into(), id.to_string().into()],
                                 Quiet::No,
                             )?;
                         }
                         PatchOperation::Diff { id } => {
                             crate::terminal::run_rad(
                             terminal::run_rad(
                                 Some("patch"),
                                 &["diff".into(), id.to_string().into()],
                                 Quiet::No,
                             )?;
                         }
                         PatchOperation::Checkout { id } => {
                             crate::terminal::run_rad(
                             terminal::run_rad(
                                 Some("patch"),
                                 &["checkout".into(), id.to_string().into()],
                                 Quiet::No,

@@ -312,7 +373,7 @@ pub async fn run(options: Options, ctx: impl terminal::Context) -> anyhow::Resul

             interface::review(opts.clone(), profile, rid, patch_id).await?;
         }
         Operation::Other { args } => {
             crate::terminal::run_rad(Some("patch"), &args, Quiet::No)?;
             terminal::run_rad(Some("patch"), &args, Quiet::No)?;
         }
         Operation::Unknown { .. } => {
             anyhow::bail!("unknown operation provided");

@@ -325,10 +386,10 @@ pub async fn run(options: Options, ctx: impl terminal::Context) -> anyhow::Resul

 mod interface {
     use anyhow::anyhow;
     use radicle::cob;
     use radicle::cob::patch::cache::Patches;
     use radicle::identity::RepoId;
     use radicle::patch::PatchId;
     use radicle::patch::Verdict;
     use radicle::patch;
     use radicle::patch::{PatchId, Verdict};
     use radicle::storage::git::cob::DraftStore;
     use radicle::storage::ReadStorage;
     use radicle::Profile;

@@ -337,8 +398,7 @@ mod interface {

     use radicle_tui::Selection;
     use crate::cob::patch;
     use crate::commands::tui_patch::common::PatchOperation;
     use crate::cob;
     use crate::tui_patch::list;
     use crate::tui_patch::review::builder::CommentBuilder;
     use crate::tui_patch::review::ReviewAction;

@@ -352,15 +412,16 @@ mod interface {

         opts: ListOptions,
         profile: Profile,
         rid: RepoId,
     ) -> anyhow::Result<Option<Selection<PatchOperation>>> {
     ) -> anyhow::Result<Option<Selection<list::PatchOperation>>> {
         let repository = profile.storage.repository(rid).unwrap();
         let me = profile.did();
         log::info!("Starting patch selection interface in project {rid}..");
         let context = list::Context {
             profile,
             repository,
             filter: opts.filter.clone(),
             filter: (me, opts.filter.clone()).into(),
         };
         list::Tui::new(context).run().await

@@ -374,14 +435,16 @@ mod interface {

     ) -> anyhow::Result<()> {
         let repo = profile.storage.repository(rid)?;
         let signer = terminal::signer(&profile)?;
         let cache = profile.patches(&repo)?;
         let patch = patch::find(&profile, &repo, &patch_id)?
         let patch = cache
             .get(&patch_id)?
             .ok_or_else(|| anyhow!("Patch `{patch_id}` not found"))?;
         let (_, revision) = opts.revision_or_latest(&patch, &repo)?;
         let hunks = ReviewBuilder::new(&repo).hunks(revision)?;
         let drafts = DraftStore::new(&repo, *signer.public_key());
         let mut patches = cob::patch::Cache::no_cache(&drafts)?;
         let mut patches = patch::Cache::no_cache(&drafts)?;
         let mut patch = patches.get_mut(&patch_id)?;
         if let Some(review) = revision.review_by(signer.public_key()) {

@@ -395,7 +458,7 @@ mod interface {

         };
         let mode = if opts.edit {
             if let Some((id, _)) = patch::find_review(&patch, revision, &signer) {
             if let Some((id, _)) = cob::find_review(&patch, revision, &signer) {
                 // Review already started, resume.
                 log::info!("Resuming review {id}..");

@@ -423,7 +486,7 @@ mod interface {

         loop {
             // Reload review
             let signer = profile.signer()?;
             let (review_id, review) = patch::find_review(&patch, revision, &signer)
             let (review_id, review) = cob::find_review(&patch, revision, &signer)
                 .ok_or_else(|| anyhow!("Could not find review."))?;
             let response = review::Tui::new(

deleted bin/commands/patch/common.rs

@@ -1,12 +0,0 @@

 use radicle::patch::PatchId;
 use serde::Serialize;
 /// The selected patch operation returned by the operation
 /// selection widget.
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
 pub enum PatchOperation {
     Checkout { id: PatchId },
     Diff { id: PatchId },
     Show { id: PatchId },
     _Review { id: PatchId },
 }

modified bin/commands/patch/list.rs

@@ -3,6 +3,8 @@ use std::sync::{Arc, Mutex};

 use anyhow::Result;
 use radicle::patch::cache::Patches;
 use radicle::patch::PatchId;
 use radicle::storage::git::Repository;
 use radicle::Profile;

@@ -13,6 +15,7 @@ use ratatui::{Frame, Viewport};

 use radicle_tui as tui;
 use serde::Serialize;
 use tui::event::Key;
 use tui::store;
 use tui::task::EmptyProcessors;

@@ -23,11 +26,9 @@ use tui::ui::im::Show;

 use tui::ui::{BufferedValue, Column, Spacing};
 use tui::{Channel, Exit};
 use super::common::PatchOperation;
 use crate::cob::patch;
 use crate::ui::items::filter::Filter;
 use crate::ui::items::{PatchItem, PatchItemFilter};
 use crate::ui::items::patch::filter::PatchFilter;
 use crate::ui::items::patch::Patch;
 const HELP: &str = r#"# Generic keybindings

@@ -53,12 +54,22 @@ const HELP: &str = r#"# Generic keybindings

 Pattern:    is:<state> | is:authored | authors:[<did>, <did>] | <search>
 Example:    is:open is:authored improve"#;
 /// The selected patch operation returned by the operation
 /// selection widget.
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
 pub enum PatchOperation {
     Checkout { id: PatchId },
     Diff { id: PatchId },
     Show { id: PatchId },
     _Review { id: PatchId },
 }
 type Selection = tui::Selection<PatchOperation>;
 pub struct Context {
     pub profile: Profile,
     pub repository: Repository,
     pub filter: patch::Filter,
     pub filter: PatchFilter,
 }
 pub struct Tui {

@@ -121,12 +132,12 @@ pub struct AppState {

     search: BufferedValue<TextEditState>,
     show_search: bool,
     help: TextViewState,
     filter: PatchItemFilter,
     filter: PatchFilter,
 }
 #[derive(Clone, Debug)]
 pub struct App {
     patches: Arc<Mutex<Vec<PatchItem>>>,
     patches: Arc<Mutex<Vec<Patch>>>,
     state: AppState,
 }

@@ -134,24 +145,21 @@ impl TryFrom<&Context> for App {

     type Error = anyhow::Error;
     fn try_from(context: &Context) -> Result<Self, Self::Error> {
         let patches = patch::all(&context.profile, &context.repository)?;
         let cache = &context.profile.patches(&context.repository)?;
         let mut patches = cache
             .list()?
             .filter_map(|patch| patch.ok())
             .flat_map(|patch| Patch::new(&context.profile, &context.repository, patch.clone()).ok())
             .collect::<Vec<_>>();
         patches.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
         let search = {
             let raw = context.filter.to_string();
             raw.trim().to_string()
         };
         let filter = PatchItemFilter::from_str(&context.filter.to_string()).unwrap_or_default();
         let mut items = patches
             .into_iter()
             .flat_map(|patch| {
                 PatchItem::new(&context.profile, &context.repository, patch.clone()).ok()
             })
             .collect::<Vec<_>>();
         items.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
         Ok(App {
             patches: Arc::new(Mutex::new(items.clone())),
             patches: Arc::new(Mutex::new(patches.clone())),
             state: AppState {
                 page: Page::Main,
                 main_group: ContainerState::new(3, Some(0)),

@@ -162,7 +170,7 @@ impl TryFrom<&Context> for App {

                 }),
                 show_search: false,
                 help: TextViewState::new(Position::default()),
                 filter,
                 filter: context.filter.clone(),
             },
         })
     }

@@ -195,8 +203,8 @@ impl store::Update<Message> for App {

                     self.state.search.reset();
                 }
                 self.state.filter =
                     PatchItemFilter::from_str(&self.state.search.read().text).unwrap_or_default();
                 self.state.filter = PatchFilter::from_str(&self.state.search.read().text)
                     .unwrap_or(PatchFilter::Invalid);
                 None
             }

@@ -215,8 +223,8 @@ impl store::Update<Message> for App {

                 }
                 Change::Search { search } => {
                     self.state.search = search;
                     self.state.filter = PatchItemFilter::from_str(&self.state.search.read().text)
                         .unwrap_or_default();
                     self.state.filter = PatchFilter::from_str(&self.state.search.read().text)
                         .unwrap_or(PatchFilter::Invalid);
                     self.state.patches.select_first();
                     None
                 }

@@ -327,12 +335,7 @@ impl App {

             Layout::vertical([Constraint::Length(3), Constraint::Min(1)]),
             Some(1),
             |ui| {
                 ui.column_bar(
                     frame,
                     header.to_vec(),
                     Spacing::default(),
                     Some(Borders::Top),
                 );
                 ui.column_bar(frame, header.to_vec(), Spacing::from(1), Some(Borders::Top));
                 let table = ui.table(
                     frame,

@@ -456,7 +459,9 @@ impl App {

                     Column::new(
                         Span::raw(format!(" {search} "))
                             .into_left_aligned_line()
                             .style(ui.theme().bar_on_black_style),
                             .style(ui.theme().bar_on_black_style)
                             .cyan()
                             .dim(),
                         Constraint::Fill(1),
                     ),
                     Column::new(

@@ -533,7 +538,9 @@ impl App {

                     Column::new(
                         Span::raw(format!(" {search} "))
                             .into_left_aligned_line()
                             .style(ui.theme().bar_on_black_style),
                             .style(ui.theme().bar_on_black_style)
                             .cyan()
                             .dim(),
                         Constraint::Fill(1),
                     ),
                     Column::new(

modified bin/commands/patch/review.rs

@@ -32,8 +32,7 @@ use tui::{Channel, Exit};

 use crate::git::HunkState;
 use crate::state::{self, FileIdentifier, FileStore, ReadState, WriteState};
 use crate::ui::format;
 use crate::ui::items::HunkItem;
 use crate::ui::items::StatefulHunkItem;
 use crate::ui::items::patch::{HunkItem, StatefulHunkItem};
 use crate::ui::layout;
 use self::builder::Hunks;

@@ -718,7 +717,7 @@ mod test {

         use radicle::storage::git::cob::DraftStore;
         use radicle::storage::git::Repository;
         use crate::cob::patch;
         use crate::cob;
         use crate::test::setup::NodeWithRepo;
         use super::builder::ReviewBuilder;

@@ -763,7 +762,7 @@ mod test {

                 &node.node.signer,
             )?;
             let (_, review) = patch::find_review(draft, revision, &node.node.signer)
             let (_, review) = cob::find_review(draft, revision, &node.node.signer)
                 .ok_or_else(|| anyhow!("Could not find review."))?;
             Ok((id, review))

modified bin/ui/items.rs

@@ -1,9 +1,8 @@

 pub mod notification;
 pub mod patch;
 use std::collections::HashMap;
 use std::fmt;
 use std::fmt::Debug;
 use std::ops::Range;
 use std::str::FromStr;
 use nom::bytes::complete::{tag, take};

@@ -11,44 +10,26 @@ use nom::multi::separated_list0;

 use nom::sequence::{delimited, preceded};
 use nom::{IResult, Parser};
 use ansi_to_tui::IntoText;
 use radicle::cob::thread::{Comment, CommentId};
 use radicle::cob::{CodeLocation, CodeRange, EntryId, Label, ObjectId, Timestamp};
 use radicle::git::Oid;
 use radicle::cob::{Label, ObjectId, Timestamp};
 use radicle::identity::Did;
 use radicle::issue;
 use radicle::issue::{CloseReason, Issue, IssueId};
 use radicle::node::{Alias, AliasStore, NodeId};
 use radicle::patch;
 use radicle::patch::{Patch, PatchId, Review};
 use radicle::storage::git::Repository;
 use radicle::storage::WriteRepository;
 use radicle::Profile;
 use radicle_surf::diff;
 use radicle_surf::diff::{Hunk, Modification};
 use radicle_cli::git::unified_diff::{Decode, HunkHeader};
 use radicle_cli::terminal;
 use radicle_cli::terminal::highlight::Highlighter;
 use ratatui::prelude::*;
 use ratatui::style::{Color, Style, Stylize};
 use ratatui::style::{Style, Stylize};
 use ratatui::widgets::Cell;
 use tui_tree_widget::TreeItem;
 use radicle_tui as tui;
 use tui::ui::utils::{LineMerger, MergeLocation};
 use tui::ui::{span, Column};
 use tui::ui::span;
 use tui::ui::{ToRow, ToTree};
 use crate::git::{Blobs, DiffStats, HunkDiff, HunkState, HunkStats};
 use crate::ui;
 use super::super::git;
 use super::format;
 pub mod filter {

@@ -64,6 +45,8 @@ pub mod filter {

     use radicle::prelude::Did;
     pub const FUZZY_MIN_SCORE: i64 = 50;
     /// A generic filter that needs be implemented for item filters in order to
     /// apply it.
     pub trait Filter<T> {

@@ -96,9 +79,11 @@ pub mod filter {

         }
     }
     fn parse_did(input: &str) -> IResult<&str, Did> {
         match Did::from_str(input) {
             Ok(did) => IResult::Ok(("", did)),
     pub fn parse_did_single(input: &str) -> IResult<&str, DidFilter> {
         let (input, did) = take(56_usize)(input)?;
         match Did::from_str(did) {
             Ok(did) => IResult::Ok((input, DidFilter::Single(did))),
             Err(_) => IResult::Err(nom::Err::Error(nom::error::Error::new(
                 input,
                 nom::error::ErrorKind::Verify,

@@ -106,10 +91,6 @@ pub mod filter {

         }
     }
     pub fn parse_did_single(input: &str) -> IResult<&str, DidFilter> {
         map(parse_did, DidFilter::Single)(input)
     }
     pub fn parse_did_or(input: &str) -> IResult<&str, DidFilter> {
         map(
             delimited(

@@ -444,206 +425,6 @@ impl FromStr for IssueItemFilter {

     }
 }
 #[derive(Clone, Debug)]
 pub struct PatchItem {
     /// Patch OID.
     pub id: PatchId,
     /// Patch state.
     pub state: patch::State,
     /// Patch title.
     pub title: String,
     /// Author of the latest revision.
     pub author: AuthorItem,
     /// Head of the latest revision.
     pub head: Oid,
     /// Lines added by the latest revision.
     pub added: u16,
     /// Lines removed by the latest revision.
     pub removed: u16,
     /// Time when patch was opened.
     pub timestamp: Timestamp,
 }
 impl PatchItem {
     pub fn new(
         profile: &Profile,
         repository: &Repository,
         patch: (PatchId, Patch),
     ) -> Result<Self, anyhow::Error> {
         let (id, patch) = patch;
         let (_, revision) = patch.latest();
         let (from, to) = revision.range();
         let stats = git::diff_stats(repository.raw(), &from, &to)?;
         Ok(Self {
             id,
             state: patch.state().clone(),
             title: patch.title().into(),
             author: AuthorItem::new(Some(*patch.author().id), profile),
             head: revision.head(),
             added: stats.insertions() as u16,
             removed: stats.deletions() as u16,
             timestamp: patch.updated_at(),
         })
     }
 }
 impl ToRow<9> for PatchItem {
     fn to_row(&self) -> [Cell<'_>; 9] {
         let (state, color) = format::patch_state(&self.state);
         let state = span::default(&state).style(Style::default().fg(color));
         let id = span::primary(&format::cob(&self.id));
         let title = span::default(&self.title.clone());
         let author = match &self.author.alias {
             Some(alias) => {
                 if self.author.you {
                     span::alias(&format!("{alias} (you)"))
                 } else {
                     span::alias(alias)
                 }
             }
             None => match &self.author.human_nid {
                 Some(nid) => span::alias(nid).dim(),
                 None => span::blank(),
             },
         };
         let did = match &self.author.human_nid {
             Some(nid) => span::alias(nid).dim(),
             None => span::blank(),
         };
         let head = span::ternary(&format::oid(self.head));
         let added = span::positive(&format!("+{}", self.added));
         let removed = span::negative(&format!("-{}", self.removed));
         let updated = span::timestamp(&format::timestamp(&self.timestamp));
         [
             state.into(),
             id.into(),
             title.into(),
             author.into(),
             did.into(),
             head.into(),
             added.into(),
             removed.into(),
             updated.into(),
         ]
     }
 }
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub struct PatchItemFilter {
     status: Option<patch::Status>,
     authored: bool,
     authors: Vec<Did>,
     search: Option<String>,
 }
 impl PatchItemFilter {
     pub fn is_default(&self) -> bool {
         *self == PatchItemFilter::default()
     }
 }
 impl filter::Filter<PatchItem> for PatchItemFilter {
     fn matches(&self, patch: &PatchItem) -> bool {
         use fuzzy_matcher::skim::SkimMatcherV2;
         use fuzzy_matcher::FuzzyMatcher;
         let matcher = SkimMatcherV2::default();
         let matches_state = match self.status {
             Some(patch::Status::Draft) => matches!(patch.state, patch::State::Draft),
             Some(patch::Status::Open) => matches!(patch.state, patch::State::Open { .. }),
             Some(patch::Status::Merged) => matches!(patch.state, patch::State::Merged { .. }),
             Some(patch::Status::Archived) => matches!(patch.state, patch::State::Archived),
             None => true,
         };
         let matches_authored = if self.authored {
             patch.author.you
         } else {
             true
         };
         let matches_authors = if !self.authors.is_empty() {
             {
                 self.authors
                     .iter()
                     .any(|other| patch.author.nid == Some(**other))
             }
         } else {
             true
         };
         let matches_search = match &self.search {
             Some(search) => match matcher.fuzzy_match(&patch.title, search) {
                 Some(score) => score == 0 || score > 60,
                 _ => false,
             },
             None => true,
         };
         matches_state && matches_authored && matches_authors && matches_search
     }
 }
 impl FromStr for PatchItemFilter {
     type Err = anyhow::Error;
     fn from_str(value: &str) -> Result<Self, Self::Err> {
         let mut status = None;
         let mut search = String::new();
         let mut authored = false;
         let mut authors = vec![];
         let mut authors_parser = |input| -> IResult<&str, Vec<&str>> {
             preceded(
                 tag("authors:"),
                 delimited(
                     tag("["),
                     separated_list0(tag(","), take(56_usize)),
                     tag("]"),
                 ),
             )(input)
         };
         let parts = value.split(' ');
         for part in parts {
             match part {
                 "is:open" => status = Some(patch::Status::Open),
                 "is:merged" => status = Some(patch::Status::Merged),
                 "is:archived" => status = Some(patch::Status::Archived),
                 "is:draft" => status = Some(patch::Status::Draft),
                 "is:authored" => authored = true,
                 other => match authors_parser.parse(other) {
                     Ok((_, dids)) => {
                         for did in dids {
                             authors.push(Did::from_str(did)?);
                         }
                     }
                     _ => search.push_str(other),
                 },
             }
         }
         let search = if search.is_empty() {
             None
         } else {
             Some(search)
         };
         Ok(Self {
             status,
             authored,
             authors,
             search,
         })
     }
 }
 /// A `CommentItem` represents a comment COB and is constructed from an `Issue` and
 /// a `Comment`.
 #[derive(Clone, Debug)]

@@ -759,955 +540,13 @@ impl ToTree<String> for CommentItem {

     }
 }
 pub struct TermLine(terminal::Line);
 impl From<TermLine> for Line<'_> {
     fn from(val: TermLine) -> Self {
         Line::raw(val.0.to_string())
     }
 }
 /// Represents the old and new ranges of a unified diff.
 pub struct DiffLineRanges {
     old: Range<u32>,
     new: Range<u32>,
 }
 impl From<&Hunk<Modification>> for DiffLineRanges {
     fn from(hunk: &Hunk<Modification>) -> Self {
         Self {
             old: hunk.old.clone(),
             new: hunk.new.clone(),
         }
     }
 }
 /// Identifies a line in a unified diff by its old and new line number.
 #[derive(Clone, Debug, Default, Hash, Eq, PartialEq)]
 pub struct DiffLineIndex {
     old: Option<u32>,
     new: Option<u32>,
 }
 impl DiffLineIndex {
     pub fn is_start_of(&self, ranges: &DiffLineRanges) -> bool {
         // TODO(erikli): Find out, why comments inserted right before or after
         // the hunk header can have such weird values.
         let old = self
             .old
             .map(|o| self.new.is_none() && o >= 4294967294)
             .unwrap_or_default();
         let new = self
             .new
             .map(|n| n == u32::MAX.saturating_sub(1) || n == ranges.new.end)
             .unwrap_or_default();
         old || new
     }
     pub fn is_end_of(&self, ranges: &DiffLineRanges) -> bool {
         let old = self
             .old
             .map(|o| o == ranges.old.end.saturating_sub(1))
             .unwrap_or_default();
         let new = self
             .new
             .map(|n| n == ranges.new.end.saturating_sub(1))
             .unwrap_or_default();
         old || new
     }
     pub fn is_inside_of(&self, ranges: &DiffLineRanges) -> bool {
         let old = self
             .old
             .map(|o| o >= ranges.old.start && o < ranges.old.end.saturating_sub(1))
             .unwrap_or_default();
         let new = self
             .new
             .map(|n| n >= ranges.new.start && n < ranges.new.end.saturating_sub(1))
             .unwrap_or_default();
         old || new
     }
 }
 /// Mention hunk header
 impl From<&CodeLocation> for DiffLineIndex {
     fn from(location: &CodeLocation) -> Self {
         Self {
             old: location.old.as_ref().map(|r| match r {
                 CodeRange::Lines { range } => range.end.saturating_sub(1) as u32,
                 CodeRange::Chars { line, range: _ } => line.saturating_sub(1) as u32,
             }),
             new: location.new.as_ref().map(|r| match r {
                 CodeRange::Lines { range } => range.end.saturating_sub(1) as u32,
                 CodeRange::Chars { line, range: _ } => line.saturating_sub(1) as u32,
             }),
         }
     }
 }
 /// A type that can map a line index to a line number in a unified diff.
 #[derive(Debug)]
 pub struct IndexedDiffLines {
     lines: HashMap<DiffLineIndex, u32>,
 }
 impl IndexedDiffLines {
     pub fn new(diff: &HunkDiff) -> Self {
         let mut indexed = HashMap::new();
         if let Some(hunk) = diff.hunk() {
             for (index, line) in hunk.lines.iter().enumerate() {
                 let line_index = match line {
                     Modification::Addition(addition) => DiffLineIndex {
                         old: None,
                         new: Some(addition.line_no),
                     },
                     Modification::Deletion(deletion) => DiffLineIndex {
                         old: Some(deletion.line_no),
                         new: None,
                     },
                     Modification::Context {
                         line: _,
                         line_no_old,
                         line_no_new,
                     } => DiffLineIndex {
                         old: Some(*line_no_old),
                         new: Some(*line_no_new),
                     },
                 };
                 indexed.insert(line_index, index as u32);
             }
         }
         Self { lines: indexed }
     }
     pub fn line(&self, index: DiffLineIndex) -> Option<u32> {
         self.lines.get(&index).copied()
     }
 }
 /// All comments per hunk, indexed by their merge location: start, line or end.
 #[derive(Clone, Debug)]
 pub struct HunkComments {
     /// All comments. Can be unsorted.
     comments: HashMap<MergeLocation, Vec<(EntryId, Comment<CodeLocation>)>>,
 }
 impl HunkComments {
     pub fn new(diff: &HunkDiff, comments: Vec<(EntryId, Comment<CodeLocation>)>) -> Self {
         let mut line_comments: HashMap<MergeLocation, Vec<(EntryId, Comment<CodeLocation>)>> =
             HashMap::new();
         let indexed = IndexedDiffLines::new(diff);
         for comment in comments {
             let line = if let Some(location) = comment.1.location() {
                 if let Some(hunk) = diff.hunk() {
                     let ranges = DiffLineRanges::from(hunk);
                     let index = DiffLineIndex::from(location);
                     if index.is_start_of(&ranges) {
                         MergeLocation::Start
                     } else if index.is_end_of(&ranges) {
                         MergeLocation::End
                     } else {
                         let mut line = indexed
                             .line(index.clone())
                             .map(|line| MergeLocation::Line(line as usize));
                         // TODO(erikli): Properly fix index lookup rules for addition:
                         // old line number need to be ignored.
                         if line.is_none() {
                             line = indexed
                                 .line(DiffLineIndex { old: None, ..index })
                                 .map(|line| MergeLocation::Line(line as usize))
                         }
                         line.unwrap_or_default()
                     }
                 } else {
                     MergeLocation::Unknown
                 }
             } else {
                 MergeLocation::Unknown
             };
             if let Some(comments) = line_comments.get_mut(&line) {
                 comments.push(comment.clone());
             } else {
                 line_comments.insert(line, vec![comment.clone()]);
             }
         }
         Self {
             comments: line_comments,
         }
     }
     pub fn all(&self) -> &HashMap<MergeLocation, Vec<(EntryId, Comment<CodeLocation>)>> {
         &self.comments
     }
     pub fn is_empty(&self) -> bool {
         self.comments.is_empty()
     }
     pub fn len(&self) -> usize {
         self.comments.values().fold(0_usize, |mut count, comments| {
             count += comments.len();
             count
         })
     }
 }
 /// A [`HunkItem`] that can be rendered. Hunk items are indexed sequentially and
 /// provide access to the underlying hunk type.
 #[derive(Clone)]
 pub struct HunkItem<'a> {
     /// The underlying hunk type and its current state (accepted / rejected).
     pub diff: HunkDiff,
     /// Raw or highlighted hunk lines. Highlighting is expensive and needs to be asynchronously.
     /// Therefor, a hunks' lines need to stored separately.
     pub lines: Blobs<Vec<Line<'a>>>,
     /// A hunks' comments, indexed by line.
     pub comments: HunkComments,
 }
 impl From<(&Repository, &Review, &HunkDiff)> for HunkItem<'_> {
     fn from(value: (&Repository, &Review, &HunkDiff)) -> Self {
         let (repo, review, item) = value;
         let hi = Highlighter::default();
         // TODO(erikli): Start with raw, non-highlighted lines and
         // move highlighting to separate task / thread, e.g. here:
         // `let lines = blobs.raw()`
         let blobs = item.clone().blobs(repo.raw());
         let lines = blobs.highlight(hi);
         // Filter comments and include them, if:
         // - comment has a code location
         // - comment path matches hunk path
         // - comment code location is inside hunk code range
         let comments = review
             .comments()
             .filter(|(_, comment)| {
                 if let Some(location) = comment.location() {
                     if location.path == *item.path() {
                         if let Some(hunk) = item.hunk() {
                             let ranges = DiffLineRanges::from(hunk);
                             let index = DiffLineIndex::from(location);
                             log::warn!("Checking comment {comment:?} at {index:?}");
                             return index.is_start_of(&ranges)
                                 || index.is_inside_of(&ranges)
                                 || index.is_end_of(&ranges);
                         } else {
                             return true;
                         }
                     }
                 }
                 false
             })
             .map(|(id, comment)| (*id, comment.clone()))
             .collect::<Vec<_>>();
         Self {
             diff: item.clone(),
             lines,
             comments: HunkComments::new(item, comments),
         }
     }
 }
 impl ToRow<3> for StatefulHunkItem<'_> {
     fn to_row(&self) -> [Cell<'_>; 3] {
         let build_stats_spans = |stats: &DiffStats| -> Vec<Span<'_>> {
             let mut cell = vec![];
             let comments = &self.inner().comments;
             if !comments.is_empty() {
                 cell.push(
                     span::default(&format!(" {} ", comments.len()))
                         .dim()
                         .reversed(),
                 );
                 cell.push(span::default(" "));
             }
             let (added, deleted) = match stats {
                 DiffStats::Hunk(stats) => (stats.added(), stats.deleted()),
                 DiffStats::File(stats) => (stats.additions, stats.deletions),
             };
             if added > 0 {
                 cell.push(span::default(&format!("+{added}")).light_green().dim());
             }
             if added > 0 && deleted > 0 {
                 cell.push(span::default(",").dim());
             }
             if deleted > 0 {
                 cell.push(span::default(&format!("-{deleted}")).light_red().dim());
             }
             cell
         };
         match &self.inner().diff {
             HunkDiff::Added {
                 path,
                 header: _,
                 new: _,
                 hunk,
                 _stats: _,
             } => {
                 let stats = hunk.as_ref().map(HunkStats::from).unwrap_or_default();
                 let stats_cell = [
                     build_stats_spans(&DiffStats::Hunk(stats)),
                     [span::default(" A ").bold().light_green().dim()].to_vec(),
                 ]
                 .concat();
                 [
                     Line::from(ui::span::hunk_state(self.state()))
                         .right_aligned()
                         .into(),
                     Line::from(ui::span::pretty_path(path, false, false)).into(),
                     Line::from(stats_cell).right_aligned().into(),
                 ]
             }
             HunkDiff::Modified {
                 path,
                 header: _,
                 old: _,
                 new: _,
                 hunk,
                 _stats: _,
             } => {
                 let stats = hunk.as_ref().map(HunkStats::from).unwrap_or_default();
                 let stats_cell = [
                     build_stats_spans(&DiffStats::Hunk(stats)),
                     [span::default(" M ").bold().light_yellow().dim()].to_vec(),
                 ]
                 .concat();
                 [
                     Line::from(ui::span::hunk_state(self.state()))
                         .right_aligned()
                         .into(),
                     Line::from(ui::span::pretty_path(path, false, false)).into(),
                     Line::from(stats_cell).right_aligned().into(),
                 ]
             }
             HunkDiff::Deleted {
                 path,
                 header: _,
                 old: _,
                 hunk,
                 _stats: _,
             } => {
                 let stats = hunk.as_ref().map(HunkStats::from).unwrap_or_default();
                 let stats_cell = [
                     build_stats_spans(&DiffStats::Hunk(stats)),
                     [span::default(" D ").bold().light_red().dim()].to_vec(),
                 ]
                 .concat();
                 [
                     Line::from(ui::span::hunk_state(self.state()))
                         .right_aligned()
                         .into(),
                     Line::from(ui::span::pretty_path(path, false, false)).into(),
                     Line::from(stats_cell).right_aligned().into(),
                 ]
             }
             HunkDiff::Copied { copied } => {
                 let stats = copied.diff.stats().copied().unwrap_or_default();
                 let stats_cell = [
                     build_stats_spans(&DiffStats::File(stats)),
                     [span::default(" CP ").bold().light_blue().dim()].to_vec(),
                 ]
                 .concat();
                 [
                     Line::from(ui::span::hunk_state(self.state()))
                         .right_aligned()
                         .into(),
                     Line::from(ui::span::pretty_path(&copied.new_path, false, false)).into(),
                     Line::from(stats_cell).right_aligned().into(),
                 ]
             }
             HunkDiff::Moved { moved } => {
                 let stats = moved.diff.stats().copied().unwrap_or_default();
                 let stats_cell = [
                     build_stats_spans(&DiffStats::File(stats)),
                     [span::default(" MV ").bold().light_blue().dim()].to_vec(),
                 ]
                 .concat();
                 [
                     Line::from(ui::span::hunk_state(self.state()))
                         .right_aligned()
                         .into(),
                     Line::from(ui::span::pretty_path(&moved.new_path, false, false)).into(),
                     Line::from(stats_cell).right_aligned().into(),
                 ]
             }
             HunkDiff::EofChanged {
                 path,
                 header: _,
                 old: _,
                 new: _,
                 _eof: _,
             } => [
                 Line::from(ui::span::hunk_state(self.state()))
                     .right_aligned()
                     .into(),
                 Line::from(ui::span::pretty_path(path, false, false)).into(),
                 Line::from(span::default("EOF ").light_blue())
                     .right_aligned()
                     .into(),
             ],
             HunkDiff::ModeChanged {
                 path,
                 header: _,
                 old: _,
                 new: _,
             } => [
                 Line::from(ui::span::hunk_state(self.state()))
                     .right_aligned()
                     .into(),
                 Line::from(ui::span::pretty_path(path, false, false)).into(),
                 Line::from(span::default("FM ").light_blue())
                     .right_aligned()
                     .into(),
             ],
         }
     }
 }
 impl<'a> HunkItem<'a> {
     pub fn header(&self) -> Vec<Column<'a>> {
         let comment_tag = if !self.comments.is_empty() {
             let count = self.comments.len();
             if count == 1 {
                 span::default(" 1 comment ").dim().reversed()
             } else {
                 span::default(&format!(" {count} comments "))
                     .dim()
                     .reversed()
             }
         } else {
             span::blank()
         };
         match &self.diff {
             HunkDiff::Added {
                 path,
                 header: _,
                 new: _,
                 hunk: _,
                 _stats: _,
             } => {
                 let path = Line::from(ui::span::pretty_path(path, false, true));
                 let header = [
                     Column::new("", Constraint::Length(0)),
                     Column::new(path.clone(), Constraint::Length(path.width() as u16)),
                     Column::new(
                         Line::from(
                             [
                                 comment_tag,
                                 span::default(" "),
                                 span::default(" added ").light_green().dim().reversed(),
                             ]
                             .to_vec(),
                         )
                         .right_aligned(),
                         Constraint::Fill(1),
                     ),
                 ];
                 header.to_vec()
             }
             HunkDiff::Modified {
                 path,
                 header: _,
                 old: _,
                 new: _,
                 hunk: _,
                 _stats: _,
             } => {
                 let path = Line::from(ui::span::pretty_path(path, false, true));
                 let header = [
                     Column::new("", Constraint::Length(0)),
                     Column::new(path.clone(), Constraint::Length(path.width() as u16)),
                     Column::new(
                         Line::from(
                             [
                                 comment_tag,
                                 span::default(" "),
                                 span::default(" modified ").light_yellow().dim().reversed(),
                             ]
                             .to_vec(),
                         )
                         .right_aligned(),
                         Constraint::Fill(1),
                     ),
                 ];
                 header.to_vec()
             }
             HunkDiff::Deleted {
                 path,
                 header: _,
                 old: _,
                 hunk: _,
                 _stats: _,
             } => {
                 let path = Line::from(ui::span::pretty_path(path, true, true));
                 let header = [
                     Column::new("", Constraint::Length(0)),
                     Column::new(path.clone(), Constraint::Length(path.width() as u16)),
                     Column::new(
                         Line::from(
                             [
                                 comment_tag,
                                 span::default(" "),
                                 span::default(" deleted ").light_red().dim().reversed(),
                             ]
                             .to_vec(),
                         )
                         .right_aligned(),
                         Constraint::Fill(1),
                     ),
                 ];
                 header.to_vec()
             }
             HunkDiff::Copied { copied } => {
                 let path = Line::from(
                     [
                         ui::span::pretty_path(&copied.old_path, false, true),
                         [span::default(" -> ")].to_vec(),
                         ui::span::pretty_path(&copied.new_path, false, true),
                     ]
                     .concat()
                     .to_vec(),
                 );
                 let header = [
                     Column::new("", Constraint::Length(0)),
                     Column::new(path.clone(), Constraint::Length(path.width() as u16)),
                     Column::new(
                         span::default(" copied ")
                             .light_blue()
                             .dim()
                             .reversed()
                             .into_right_aligned_line(),
                         Constraint::Fill(1),
                     ),
                 ];
                 header.to_vec()
             }
             HunkDiff::Moved { moved } => {
                 let path = Line::from(
                     [
                         ui::span::pretty_path(&moved.old_path, false, true),
                         [span::default(" -> ")].to_vec(),
                         ui::span::pretty_path(&moved.new_path, false, true),
                     ]
                     .concat()
                     .to_vec(),
                 );
                 let header = [
                     Column::new("", Constraint::Length(0)),
                     Column::new(path.clone(), Constraint::Length(path.width() as u16)),
                     Column::new(
                         span::default(" moved ")
                             .light_blue()
                             .dim()
                             .reversed()
                             .into_right_aligned_line(),
                         Constraint::Fill(1),
                     ),
                 ];
                 header.to_vec()
             }
             HunkDiff::EofChanged {
                 path,
                 header: _,
                 old: _,
                 new: _,
                 _eof: _,
             } => {
                 let path = Line::from(ui::span::pretty_path(path, false, true));
                 let header = [
                     Column::new("", Constraint::Length(0)),
                     Column::new(path.clone(), Constraint::Length(path.width() as u16)),
                     Column::new(
                         span::default(" eof ")
                             .dim()
                             .reversed()
                             .into_right_aligned_line(),
                         Constraint::Fill(1),
                     ),
                 ];
                 header.to_vec()
             }
             HunkDiff::ModeChanged {
                 path,
                 header: _,
                 old: _,
                 new: _,
             } => {
                 let path = Line::from(ui::span::pretty_path(path, false, true));
                 let header = [
                     Column::new("", Constraint::Length(0)),
                     Column::new(path.clone(), Constraint::Length(path.width() as u16)),
                     Column::new(
                         span::default(" mode ")
                             .dim()
                             .reversed()
                             .into_right_aligned_line(),
                         Constraint::Length(6),
                     ),
                 ];
                 header.to_vec()
             }
         }
     }
     pub fn hunk_text(&'a self) -> Option<Text<'a>> {
         match &self.diff {
             HunkDiff::Added { hunk, .. }
             | HunkDiff::Modified { hunk, .. }
             | HunkDiff::Deleted { hunk, .. } => {
                 let mut lines = hunk
                     .as_ref()
                     .map(|hunk| Text::from(hunk.to_text(&self.lines)));
                 lines = lines.map(|lines| {
                     let divider = span::default(&"─".to_string().repeat(500)).gray().dim();
                     let mut merge = HashMap::new();
                     for (line, comments) in self.comments.all() {
                         merge.insert(
                             line.clone(),
                             comments
                                 .iter()
                                 .enumerate()
                                 .map(|(idx, comment)| {
                                     let timestamp =
                                         span::timestamp(&format::timestamp(&comment.1.timestamp()));
                                     let author =
                                         span::alias(&format::did(&Did::from(comment.1.author())));
                                     let mut rendered = vec![];
                                     // Only add top divider for the first comment
                                     if idx == 0 {
                                         rendered.push(Line::from([divider.clone()].to_vec()));
                                     }
                                     // Add comment body
                                     rendered.extend(comment.1.body().lines().map(|line| {
                                         Line::from([span::default(line).gray()].to_vec())
                                     }));
                                     // Add metadata
                                     rendered.push(
                                         Line::from(
                                             [timestamp, span::default(" by ").dim(), author]
                                                 .to_vec(),
                                         )
                                         .right_aligned(),
                                     );
                                     // Add bottom divider
                                     rendered.push(Line::from([divider.clone()].to_vec()));
                                     rendered
                                 })
                                 .collect(),
                         );
                     }
                     let merged = LineMerger::new(lines.lines).merge(merge, None);
                     Text::from(merged)
                 });
                 lines
             }
             _ => None,
         }
     }
 }
 impl Debug for HunkItem<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("HunkItem")
             .field("inner", &self.diff)
             .field("comments", &self.comments)
             .finish()
     }
 }
 #[derive(Clone, Debug)]
 pub struct StatefulHunkItem<'a>(HunkItem<'a>, HunkState);
 impl<'a> StatefulHunkItem<'a> {
     pub fn new(inner: HunkItem<'a>, state: HunkState) -> Self {
         Self(inner, state)
     }
     pub fn inner(&self) -> &HunkItem<'a> {
         &self.0
     }
     pub fn state(&self) -> &HunkState {
         &self.1
     }
     pub fn update_state(&mut self, state: &HunkState) {
         self.1 = state.clone();
     }
 }
 pub struct HighlightedLine<'a>(Line<'a>);
 impl<'a> From<Line<'a>> for HighlightedLine<'a> {
     fn from(highlighted: Line<'a>) -> Self {
         let converted = highlighted.to_string().into_text().unwrap().lines;
         Self(converted.first().cloned().unwrap_or_default())
     }
 }
 impl<'a> From<HighlightedLine<'a>> for Line<'a> {
     fn from(val: HighlightedLine<'a>) -> Self {
         val.0
     }
 }
 /// Types that can be rendered as texts.
 pub trait ToText<'a> {
     /// The output of the render process.
     type Output: Into<Text<'a>>;
     /// Context that can be passed down from parent objects during rendering.
     type Context;
     /// Render to pretty diff output.
     fn to_text(&'a self, context: &Self::Context) -> Self::Output;
 }
 impl<'a> ToText<'a> for HunkHeader {
     type Output = Line<'a>;
     type Context = ();
     fn to_text(&self, _context: &Self::Context) -> Self::Output {
         Line::from(
             [
                 span::default(&format!(
                     "@@ -{},{} +{},{} @@",
                     self.old_line_no, self.old_size, self.new_line_no, self.new_size,
                 ))
                 .gray(),
                 span::default(" "),
                 span::default(String::from_utf8_lossy(&self.text).as_ref()),
             ]
             .to_vec(),
         )
     }
 }
 impl<'a> ToText<'a> for Modification {
     type Output = Line<'a>;
     type Context = Blobs<Vec<Line<'a>>>;
     fn to_text(&'a self, blobs: &Blobs<Vec<Line<'a>>>) -> Self::Output {
         let line = match self {
             Modification::Deletion(diff::Deletion { line, line_no }) => {
                 if let Some(lines) = &blobs.old.as_ref() {
                     lines[*line_no as usize - 1].clone()
                 } else {
                     Line::raw(String::from_utf8_lossy(line.as_bytes()))
                 }
             }
             Modification::Addition(diff::Addition { line, line_no }) => {
                 if let Some(lines) = &blobs.new.as_ref() {
                     lines[*line_no as usize - 1].clone()
                 } else {
                     Line::raw(String::from_utf8_lossy(line.as_bytes()))
                 }
             }
             Modification::Context {
                 line, line_no_new, ..
             } => {
                 // Nb. we can check in the old or the new blob, we choose the new.
                 if let Some(lines) = &blobs.new.as_ref() {
                     lines[*line_no_new as usize - 1].clone()
                 } else {
                     Line::raw(String::from_utf8_lossy(line.as_bytes()))
                 }
             }
         };
         HighlightedLine::from(line).into()
     }
 }
 impl<'a> ToText<'a> for Hunk<Modification> {
     type Output = Vec<Line<'a>>;
     type Context = Blobs<Vec<Line<'a>>>;
     fn to_text(&'a self, blobs: &Self::Context) -> Self::Output {
         let mut lines: Vec<Line<'a>> = vec![];
         let default_dark = Color::Rgb(20, 20, 20);
         let positive_light = Color::Rgb(10, 60, 20);
         let positive_dark = Color::Rgb(10, 30, 20);
         let negative_light = Color::Rgb(60, 10, 20);
         let negative_dark = Color::Rgb(30, 10, 20);
         if let Ok(header) = HunkHeader::from_bytes(self.header.as_bytes()) {
             lines.push(Line::from(
                 [
                     span::default(&format!(
                         "@@ -{},{} +{},{} @@",
                         header.old_line_no, header.old_size, header.new_line_no, header.new_size,
                     ))
                     .gray()
                     .dim(),
                     span::default(" "),
                     span::default(String::from_utf8_lossy(&header.text).as_ref())
                         .gray()
                         .dim(),
                 ]
                 .to_vec(),
             ))
         }
         for line in &self.lines {
             match line {
                 Modification::Addition(a) => {
                     lines.push(Line::from(
                         [
                             [
                                 span::positive(&format!("{:<5}", ""))
                                     .bg(positive_light)
                                     .dim(),
                                 span::positive(&format!("{:<5}", &a.line_no.to_string()))
                                     .bg(positive_light)
                                     .dim(),
                                 span::positive(" + ").bg(positive_dark).dim(),
                             ]
                             .to_vec(),
                             line.to_text(blobs)
                                 .spans
                                 .into_iter()
                                 .map(|span| span.bg(positive_dark))
                                 .collect::<Vec<_>>(),
                             [span::positive(&format!("{:<500}", "")).bg(positive_dark)].to_vec(),
                         ]
                         .concat(),
                     ));
                 }
                 Modification::Deletion(d) => {
                     lines.push(Line::from(
                         [
                             [
                                 span::negative(&format!("{:<5}", &d.line_no.to_string()))
                                     .bg(negative_light)
                                     .dim(),
                                 span::negative(&format!("{:<5}", ""))
                                     .bg(negative_light)
                                     .dim(),
                                 span::negative(" - ").bg(negative_dark).dim(),
                             ]
                             .to_vec(),
                             line.to_text(blobs)
                                 .spans
                                 .into_iter()
                                 .map(|span| span.bg(negative_dark))
                                 .collect::<Vec<_>>(),
                             [span::positive(&format!("{:<500}", "")).bg(negative_dark)].to_vec(),
                         ]
                         .concat(),
                     ));
                 }
                 Modification::Context {
                     line_no_old,
                     line_no_new,
                     ..
                 } => {
                     lines.push(Line::from(
                         [
                             [
                                 span::default(&format!("{:<5}", &line_no_old.to_string()))
                                     .bg(default_dark)
                                     .gray()
                                     .dim(),
                                 span::default(&format!("{:<5}", &line_no_new.to_string()))
                                     .bg(default_dark)
                                     .gray()
                                     .dim(),
                                 span::default(&format!("{:<3}", "")),
                             ]
                             .to_vec(),
                             line.to_text(blobs).spans,
                         ]
                         .concat(),
                     ));
                 }
             }
         }
         lines
     }
 }
 #[cfg(test)]
 mod tests {
     use std::path::PathBuf;
     use anyhow::Result;
     use crate::test;
     use super::*;
     #[test]
     fn patch_item_filter_from_str_should_succeed() -> Result<()> {
         let search = r#"is:open is:authored authors:[did:key:z6MkkpTPzcq1ybmjQyQpyre15JUeMvZY6toxoZVpLZ8YarsB,did:key:z6Mku8hpprWTmCv3BqkssCYDfr2feUdyLSUnycVajFo9XVAx] cli"#;
         let actual = PatchItemFilter::from_str(search)?;
         let expected = PatchItemFilter {
             status: Some(patch::Status::Open),
             authored: true,
             authors: vec![
                 Did::from_str("did:key:z6MkkpTPzcq1ybmjQyQpyre15JUeMvZY6toxoZVpLZ8YarsB")?,
                 Did::from_str("did:key:z6Mku8hpprWTmCv3BqkssCYDfr2feUdyLSUnycVajFo9XVAx")?,
             ],
             search: Some("cli".to_string()),
         };
         assert_eq!(expected, actual);
         Ok(())
     }
     #[test]
     fn issue_item_filter_from_str_should_succeed() -> Result<()> {
         let search = r#"is:open is:assigned assignees:[did:key:z6MkkpTPzcq1ybmjQyQpyre15JUeMvZY6toxoZVpLZ8YarsB,did:key:z6Mku8hpprWTmCv3BqkssCYDfr2feUdyLSUnycVajFo9XVAx] is:authored authors:[did:key:z6Mku8hpprWTmCv3BqkssCYDfr2feUdyLSUnycVajFo9XVAx] cli"#;
         let actual = IssueItemFilter::from_str(search)?;

@@ -1730,351 +569,4 @@ mod tests {

         Ok(())
     }
     #[test]
     fn diff_line_index_checks_ranges_correctly() -> Result<()> {
         let commit = Oid::from_str("a32c4b93e2573fd83b15ac1ad6bf1317dc8fd760").unwrap();
         let path = PathBuf::from_str("main.rs").unwrap();
         // --------------------------------------------------------------------
         // At the top.
         // --------------------------------------------------------------------
         // @@ -3,8 +3,7 @@
         // 3   3     // or if you prefer to use your keyboard, you can use the "Ctrl + Enter"
         // 4   4     // shortcut.
         // 5   5
         // 6       - // This code is editable, feel free to hack it!
         // 7       - // You can always return to the original code by clicking the "Reset" button ->
         //     6   + // This is still a comment.
         // --------------------------------------------------------------------
         // In the middle.
         // --------------------------------------------------------------------
         // 8   7
         // 9   8     // This is the main function.
         // 10  9     fn main() {
         // ---------------------------------------------------------------------
         // At the end.
         // ---------------------------------------------------------------------
         let diff = test::fixtures::simple_modified_hunk_diff(&path, commit)?;
         let ranges = DiffLineRanges::from(diff.hunk().unwrap());
         let start = CodeLocation {
             commit,
             path: path.clone(),
             old: Some(CodeRange::Lines { range: 3..12 }),
             new: Some(CodeRange::Lines { range: 3..11 }),
         };
         assert!(DiffLineIndex::from(&start).is_start_of(&ranges));
         assert!(!DiffLineIndex::from(&start).is_inside_of(&ranges));
         assert!(!DiffLineIndex::from(&start).is_end_of(&ranges));
         let inside = CodeLocation {
             commit,
             path: path.clone(),
             old: Some(CodeRange::Lines { range: 3..8 }),
             new: Some(CodeRange::Lines { range: 3..7 }),
         };
         assert!(DiffLineIndex::from(&inside).is_inside_of(&ranges));
         assert!(!DiffLineIndex::from(&inside).is_start_of(&ranges));
         assert!(!DiffLineIndex::from(&inside).is_end_of(&ranges));
         let end = CodeLocation {
             commit,
             path: path.clone(),
             old: Some(CodeRange::Lines { range: 3..11 }),
             new: Some(CodeRange::Lines { range: 3..10 }),
         };
         assert!(DiffLineIndex::from(&end).is_end_of(&ranges));
         assert!(!DiffLineIndex::from(&end).is_start_of(&ranges));
         assert!(!DiffLineIndex::from(&end).is_inside_of(&ranges));
         let outside = CodeLocation {
             commit,
             path: path.clone(),
             old: Some(CodeRange::Lines { range: 125..127 }),
             new: Some(CodeRange::Lines { range: 125..128 }),
         };
         assert!(!DiffLineIndex::from(&outside).is_start_of(&ranges));
         assert!(!DiffLineIndex::from(&outside).is_inside_of(&ranges));
         assert!(!DiffLineIndex::from(&outside).is_end_of(&ranges));
         Ok(())
     }
     #[test]
     fn hunk_comments_on_modified_simple_are_inserted_correctly() -> Result<()> {
         let alice = test::fixtures::node_with_repo();
         let commit = Oid::from_str("a32c4b93e2573fd83b15ac1ad6bf1317dc8fd760").unwrap();
         let path = PathBuf::from_str("main.rs").unwrap();
         // --------------------------------------------------------------------
         // At the top.
         // --------------------------------------------------------------------
         // @@ -3,8 +3,7 @@
         // 3   3     // or if you prefer to use your keyboard, you can use the "Ctrl + Enter"
         // 4   4     // shortcut.
         // 5   5
         // 6       - // This code is editable, feel free to hack it!
         // 7       - // You can always return to the original code by clicking the "Reset" button ->
         //     6   + // This is still a comment.
         // --------------------------------------------------------------------
         // In the middle.
         // --------------------------------------------------------------------
         // 8   7
         // 9   8     // This is the main function.
         // 10  9     fn main() {
         // ---------------------------------------------------------------------
         // At the end.
         // ---------------------------------------------------------------------
         let diff = test::fixtures::simple_modified_hunk_diff(&path, commit)?;
         let top = (
             Oid::from_str("05ac6202655dcde6c2613702fec07c2e2fe8f382").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "At the top.".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 3..12 }),
                     new: Some(CodeRange::Lines { range: 3..11 }),
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let middle = (
             Oid::from_str("2d09104bf2d6ad328aa72594b679d2d6c5a61865").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "In the middle.".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 3..8 }),
                     new: Some(CodeRange::Lines { range: 3..7 }),
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let end = (
             Oid::from_str("8280317b308ba1bf2cef04533efb15d920431e86").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "At the end.".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 3..11 }),
                     new: Some(CodeRange::Lines { range: 3..10 }),
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let comments = {
             let comments = [top.clone(), middle.clone(), end.clone()];
             HunkComments::new(&diff, comments.to_vec())
         };
         for expected in [
             (top, MergeLocation::Start),
             (middle, MergeLocation::Line(5)),
             (end, MergeLocation::End),
         ] {
             let (line, expected) = (expected.1, expected.0);
             let actual = comments.all().get(&line);
             assert_ne!(actual, None, "No comment found at {line:?}");
             let actual = actual.unwrap().first().unwrap();
             assert_eq!(actual.0, expected.0);
         }
         Ok(())
     }
     #[test]
     fn hunk_comments_on_modified_complex_are_inserted_correctly() -> Result<()> {
         let alice = test::fixtures::node_with_repo();
         let commit = Oid::from_str("a32c4b93e2573fd83b15ac1ad6bf1317dc8fd760").unwrap();
         let path = PathBuf::from_str("main.rs").unwrap();
         // --------------------------------------------------------------------
         // At the top.
         // --------------------------------------------------------------------
         // @@ -1,17 +1,15 @@
         // 1       - use radicle::issue::IssueId;
         // 2       - use tui::ui::state::ItemState;
         // 3       - use tui::SelectionExit;
         // --------------------------------------------------------------------
         // After deletion.
         // --------------------------------------------------------------------
         // 4   1     use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection};
         // 5   2     use tuirealm::event::{Event, Key, KeyEvent};
         // 6   3     use tuirealm::{MockComponent, NoUserEvent};
         // 7   4
         // 8   5     use radicle_tui as tui;
         // 9   6
         //     7   + use tui::ui::state::ItemState;
         // 10  8     use tui::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer};
         // 11  9     use tui::ui::widget::context::{ContextBar, Shortcuts};
         // 12  10    use tui::ui::widget::list::PropertyList;
         // 13      -
         // 14  11    use tui::ui::widget::Widget;
         //     12  + use tui::{Id, SelectionExit};
         // 15  13
         // 16  14    use super::ui::{IdSelect, OperationSelect};
         // --------------------------------------------------------------------
         // Before last line.
         // --------------------------------------------------------------------
         // 17  15    use super::{IssueOperation, Message};
         let diff = test::fixtures::complex_modified_hunk_diff(&path, commit)?;
         let top = (
             Oid::from_str("05ac6202655dcde6c2613702fec07c2e2fe8f382").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "At the top.".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 1..18 }),
                     new: Some(CodeRange::Lines { range: 1..17 }),
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let after_deletion = (
             Oid::from_str("2d09104bf2d6ad328aa72594b679d2d6c5a61865").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "After deletion.".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 1..4 }),
                     new: None,
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let before_last_line = (
             Oid::from_str("60972bca0c9e686e76b0a5123acb3c8c60c38b1e").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "Before last line".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 1..17 }),
                     new: Some(CodeRange::Lines { range: 1..15 }),
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let comments = {
             let comments = [
                 top.clone(),
                 after_deletion.clone(),
                 before_last_line.clone(),
             ];
             HunkComments::new(&diff, comments.to_vec())
         };
         for expected in [
             (top, MergeLocation::Start),
             (after_deletion, MergeLocation::Line(2)),
             (before_last_line, MergeLocation::Line(17)),
         ] {
             let (line, expected) = (expected.1, expected.0);
             let actual = comments.all().get(&line);
             assert_ne!(actual, None, "No comment found at {line:?}");
             let actual = actual.unwrap().first().unwrap();
             assert_eq!(actual.0, expected.0);
         }
         Ok(())
     }
     #[test]
     fn hunk_comments_on_deleted_simple_are_inserted_correctly() -> Result<()> {
         let alice = test::fixtures::node_with_repo();
         let commit = Oid::from_str("a32c4b93e2573fd83b15ac1ad6bf1317dc8fd760").unwrap();
         let path = PathBuf::from_str("README.md").unwrap();
         // --------------------------------------------------------------------
         // At the top.
         // --------------------------------------------------------------------
         // @@ -1,1 +0,0 @@
         //  -TBD
         // --------------------------------------------------------------------
         // At the end.
         // --------------------------------------------------------------------
         let diff = test::fixtures::deleted_hunk_diff(&path, commit)?;
         let top = (
             Oid::from_str("05ac6202655dcde6c2613702fec07c2e2fe8f382").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "At the top.".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 1..3 }),
                     new: Some(CodeRange::Lines { range: 0..1 }),
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let end = (
             Oid::from_str("8280317b308ba1bf2cef04533efb15d920431e86").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "At the end.".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 1..2 }),
                     new: None,
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let comments = {
             let comments = [top.clone(), end.clone()];
             HunkComments::new(&diff, comments.to_vec())
         };
         for expected in [(top, MergeLocation::Start), (end, MergeLocation::End)] {
             let (line, expected) = (expected.1, expected.0);
             let actual = comments.all().get(&line);
             assert_ne!(actual, None, "No comment found at {line:?}");
             let actual = actual.unwrap().first().unwrap();
             assert_eq!(actual.0, expected.0);
         }
         Ok(())
     }
 }

modified bin/ui/items/notification.rs

@@ -789,4 +789,36 @@ mod tests {

         Ok(())
     }
     #[test]
     fn notification_item_filter_with_all_shuffled_should_succeed() -> Result<()> {
         let search = r#"kind=(cob:xyz.radicle.patch or cob:xyz.radicle.issue) author=did:key:z6Mku8hpprWTmCv3BqkssCYDfr2feUdyLSUnycVajFo9XVAx state=seen cli"#;
         let actual = NotificationFilter::from_str(search)?;
         let expected = NotificationFilter::And(vec![
             NotificationFilter::Kind(NotificationKindFilter::Or(vec![
                 NotificationKind::Cob {
                     type_name: TypeName::from_str("xyz.radicle.patch").ok(),
                     summary: None,
                     status: None,
                     id: None,
                 },
                 NotificationKind::Cob {
                     type_name: TypeName::from_str("xyz.radicle.issue").ok(),
                     summary: None,
                     status: None,
                     id: None,
                 },
             ])),
             NotificationFilter::Author(DidFilter::Single(Did::from_str(
                 "did:key:z6Mku8hpprWTmCv3BqkssCYDfr2feUdyLSUnycVajFo9XVAx",
             )?)),
             NotificationFilter::State(NotificationState::Seen),
             NotificationFilter::Search("cli".to_string()),
         ]);
         assert_eq!(expected, actual);
         Ok(())
     }
 }

added bin/ui/items/patch.rs

@@ -0,0 +1,1646 @@

 use std::collections::HashMap;
 use std::fmt;
 use std::fmt::Debug;
 use std::ops::Range;
 use ansi_to_tui::IntoText;
 use radicle::cob::thread::Comment;
 use radicle::cob::{CodeLocation, CodeRange, EntryId, Timestamp};
 use radicle::git::Oid;
 use radicle::patch::{PatchId, Review};
 use radicle::prelude::Did;
 use radicle::storage::git::Repository;
 use radicle::storage::WriteRepository;
 use radicle::Profile;
 use radicle_surf::diff;
 use radicle_surf::diff::{Hunk, Modification};
 use radicle_cli::git::unified_diff::{Decode, HunkHeader};
 use radicle_cli::terminal::highlight::Highlighter;
 use ratatui::layout::Constraint;
 use ratatui::style::{Color, Style, Stylize};
 use ratatui::text::{Line, Span, Text};
 use ratatui::widgets::Cell;
 use radicle_tui as tui;
 use tui::ui::span;
 use tui::ui::utils::LineMerger;
 use tui::ui::utils::MergeLocation;
 use tui::ui::{Column, ToRow};
 use crate::git::{self, Blobs, DiffStats, HunkDiff, HunkState, HunkStats};
 use crate::ui;
 use super::format;
 use super::AuthorItem;
 #[derive(Clone, Debug)]
 pub struct Patch {
     /// Patch OID.
     pub id: PatchId,
     /// Patch state.
     pub state: radicle::patch::State,
     /// Patch title.
     pub title: String,
     /// Author of the latest revision.
     pub author: AuthorItem,
     /// Head of the latest revision.
     pub head: Oid,
     /// Lines added by the latest revision.
     pub added: u16,
     /// Lines removed by the latest revision.
     pub removed: u16,
     /// Time when patch was opened.
     pub timestamp: Timestamp,
 }
 impl Patch {
     pub fn new(
         profile: &Profile,
         repository: &Repository,
         patch: (PatchId, radicle::patch::Patch),
     ) -> Result<Self, anyhow::Error> {
         let (id, patch) = patch;
         let (_, revision) = patch.latest();
         let (from, to) = revision.range();
         let stats = git::diff_stats(repository.raw(), &from, &to)?;
         Ok(Self {
             id,
             state: patch.state().clone(),
             title: patch.title().into(),
             author: AuthorItem::new(Some(*patch.author().id), profile),
             head: revision.head(),
             added: stats.insertions() as u16,
             removed: stats.deletions() as u16,
             timestamp: patch.updated_at(),
         })
     }
 }
 impl ToRow<9> for Patch {
     fn to_row(&self) -> [Cell<'_>; 9] {
         let (state, color) = format::patch_state(&self.state);
         let state = span::default(&state).style(Style::default().fg(color));
         let id = span::primary(&format::cob(&self.id));
         let title = span::default(&self.title.clone());
         let author = match &self.author.alias {
             Some(alias) => {
                 if self.author.you {
                     span::alias(&format!("{alias} (you)"))
                 } else {
                     span::alias(alias)
                 }
             }
             None => match &self.author.human_nid {
                 Some(nid) => span::alias(nid).dim(),
                 None => span::blank(),
             },
         };
         let did = match &self.author.human_nid {
             Some(nid) => span::alias(nid).dim(),
             None => span::blank(),
         };
         let head = span::ternary(&format::oid(self.head));
         let added = span::positive(&format!("+{}", self.added));
         let removed = span::negative(&format!("-{}", self.removed));
         let updated = span::timestamp(&format::timestamp(&self.timestamp));
         [
             state.into(),
             id.into(),
             title.into(),
             author.into(),
             did.into(),
             head.into(),
             added.into(),
             removed.into(),
             updated.into(),
         ]
     }
 }
 pub mod filter {
     use std::fmt;
     use std::fmt::Debug;
     use std::fmt::Write as _;
     use std::str::FromStr;
     use nom::branch::alt;
     use nom::bytes::complete::{tag_no_case, take_while1};
     use nom::character::complete::multispace0;
     use nom::combinator::{map, value};
     use nom::multi::many0;
     use nom::sequence::{preceded, tuple};
     use nom::IResult;
     use radicle::patch::Status;
     use crate::ui::items::filter;
     use crate::ui::items::filter::DidFilter;
     use crate::ui::items::filter::Filter;
     use super::Patch;
     #[derive(Clone, Debug, Eq, PartialEq)]
     pub enum PatchFilter {
         State(Status),
         Author(DidFilter),
         Search(String),
         And(Vec<PatchFilter>),
         Empty,
         Invalid,
     }
     impl Default for PatchFilter {
         fn default() -> Self {
             PatchFilter::State(Status::Open)
         }
     }
     impl PatchFilter {
         pub fn is_default(&self) -> bool {
             *self == PatchFilter::default()
         }
     }
     impl fmt::Display for PatchFilter {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             match self {
                 PatchFilter::State(state) => {
                     write!(f, "state={state}")?;
                     f.write_char(' ')?;
                 }
                 PatchFilter::Author(filter) => {
                     write!(f, "author={filter}")?;
                     f.write_char(' ')?;
                 }
                 PatchFilter::Search(search) => {
                     write!(f, "{search}")?;
                     f.write_char(' ')?;
                 }
                 PatchFilter::And(filters) => {
                     let mut it = filters.iter().peekable();
                     while let Some(filter) = it.next() {
                         write!(f, "{filter}")?;
                         if it.peek().is_none() {
                             f.write_char(' ')?;
                         }
                     }
                 }
                 PatchFilter::Empty | PatchFilter::Invalid => {}
             }
             Ok(())
         }
     }
     impl Filter<Patch> for PatchFilter {
         fn matches(&self, patch: &Patch) -> bool {
             use fuzzy_matcher::skim::SkimMatcherV2;
             use fuzzy_matcher::FuzzyMatcher;
             let matcher = SkimMatcherV2::default();
             match self {
                 PatchFilter::State(state) => Status::from(&patch.state) == *state,
                 PatchFilter::Author(author_filter) => match author_filter {
                     DidFilter::Single(author) => patch.author.nid == Some(**author),
                     DidFilter::Or(authors) => authors
                         .iter()
                         .any(|other| patch.author.nid == Some(**other)),
                 },
                 PatchFilter::Search(search) => {
                     match matcher.fuzzy_match(
                         &format!(
                             "{} {} {}",
                             &patch.id.to_string(),
                             &patch.title,
                             &patch
                                 .author
                                 .alias
                                 .as_ref()
                                 .map(|a| a.to_string())
                                 .unwrap_or_default()
                         ),
                         search,
                     ) {
                         Some(score) => score == 0 || score > filter::FUZZY_MIN_SCORE,
                         _ => false,
                     }
                 }
                 PatchFilter::And(filters) => filters.iter().all(|f| f.matches(patch)),
                 PatchFilter::Empty => true,
                 PatchFilter::Invalid => false,
             }
         }
     }
     impl FromStr for PatchFilter {
         type Err = anyhow::Error;
         fn from_str(filter_exp: &str) -> Result<Self, Self::Err> {
             fn parse_state(input: &str) -> IResult<&str, Status> {
                 alt((
                     value(Status::Open, tag_no_case("open")),
                     value(Status::Merged, tag_no_case("merged")),
                     value(Status::Draft, tag_no_case("draft")),
                     value(Status::Archived, tag_no_case("archived")),
                 ))(input)
             }
             fn parse_state_filter(input: &str) -> IResult<&str, PatchFilter> {
                 map(
                     preceded(
                         tuple((
                             tag_no_case("state"),
                             multispace0,
                             tag_no_case("="),
                             multispace0,
                         )),
                         parse_state,
                     ),
                     PatchFilter::State,
                 )(input)
             }
             fn parse_author_filter(input: &str) -> IResult<&str, PatchFilter> {
                 map(
                     preceded(
                         tuple((
                             tag_no_case("author"),
                             multispace0,
                             tag_no_case("="),
                             multispace0,
                         )),
                         alt((filter::parse_did_single, filter::parse_did_or)),
                     ),
                     PatchFilter::Author,
                 )(input)
             }
             fn parse_search_filter(input: &str) -> IResult<&str, PatchFilter> {
                 map(
                     take_while1(|c: char| c.is_alphanumeric() || c == '_' || c == '-'),
                     |s: &str| PatchFilter::Search(s.to_string()),
                 )(input)
             }
             fn parse_single_filter(input: &str) -> IResult<&str, PatchFilter> {
                 alt((parse_state_filter, parse_author_filter, parse_search_filter))(input)
             }
             fn parse_filters(input: &str) -> IResult<&str, Vec<PatchFilter>> {
                 many0(preceded(multispace0, parse_single_filter))(input)
             }
             let parse_filter_expression = |input: &str| -> Result<PatchFilter, String> {
                 match parse_filters(input) {
                     Ok((remaining, filters)) => {
                         let remaining = remaining.trim();
                         if !remaining.is_empty() {
                             return Err(format!("Unparsed input remaining: '{remaining}'"));
                         }
                         if filters.is_empty() {
                             return Ok(PatchFilter::Empty);
                         }
                         if filters.len() == 1 {
                             Ok(filters.into_iter().next().unwrap())
                         } else {
                             Ok(PatchFilter::And(filters))
                         }
                     }
                     Err(e) => Err(format!("Parse error: {e}")),
                 }
             };
             parse_filter_expression(filter_exp).map_err(|err| anyhow::format_err!(err))
         }
     }
 }
 pub struct TermLine(radicle_cli::terminal::Line);
 impl From<TermLine> for Line<'_> {
     fn from(val: TermLine) -> Self {
         Line::raw(val.0.to_string())
     }
 }
 /// Represents the old and new ranges of a unified diff.
 pub struct DiffLineRanges {
     old: Range<u32>,
     new: Range<u32>,
 }
 impl From<&Hunk<Modification>> for DiffLineRanges {
     fn from(hunk: &Hunk<Modification>) -> Self {
         Self {
             old: hunk.old.clone(),
             new: hunk.new.clone(),
         }
     }
 }
 /// Identifies a line in a unified diff by its old and new line number.
 #[derive(Clone, Debug, Default, Hash, Eq, PartialEq)]
 pub struct DiffLineIndex {
     old: Option<u32>,
     new: Option<u32>,
 }
 impl DiffLineIndex {
     pub fn is_start_of(&self, ranges: &DiffLineRanges) -> bool {
         // TODO(erikli): Find out, why comments inserted right before or after
         // the hunk header can have such weird values.
         let old = self
             .old
             .map(|o| self.new.is_none() && o >= 4294967294)
             .unwrap_or_default();
         let new = self
             .new
             .map(|n| n == u32::MAX.saturating_sub(1) || n == ranges.new.end)
             .unwrap_or_default();
         old || new
     }
     pub fn is_end_of(&self, ranges: &DiffLineRanges) -> bool {
         let old = self
             .old
             .map(|o| o == ranges.old.end.saturating_sub(1))
             .unwrap_or_default();
         let new = self
             .new
             .map(|n| n == ranges.new.end.saturating_sub(1))
             .unwrap_or_default();
         old || new
     }
     pub fn is_inside_of(&self, ranges: &DiffLineRanges) -> bool {
         let old = self
             .old
             .map(|o| o >= ranges.old.start && o < ranges.old.end.saturating_sub(1))
             .unwrap_or_default();
         let new = self
             .new
             .map(|n| n >= ranges.new.start && n < ranges.new.end.saturating_sub(1))
             .unwrap_or_default();
         old || new
     }
 }
 /// Mention hunk header
 impl From<&CodeLocation> for DiffLineIndex {
     fn from(location: &CodeLocation) -> Self {
         Self {
             old: location.old.as_ref().map(|r| match r {
                 CodeRange::Lines { range } => range.end.saturating_sub(1) as u32,
                 CodeRange::Chars { line, range: _ } => line.saturating_sub(1) as u32,
             }),
             new: location.new.as_ref().map(|r| match r {
                 CodeRange::Lines { range } => range.end.saturating_sub(1) as u32,
                 CodeRange::Chars { line, range: _ } => line.saturating_sub(1) as u32,
             }),
         }
     }
 }
 /// A type that can map a line index to a line number in a unified diff.
 #[derive(Debug)]
 pub struct IndexedDiffLines {
     lines: HashMap<DiffLineIndex, u32>,
 }
 impl IndexedDiffLines {
     pub fn new(diff: &HunkDiff) -> Self {
         let mut indexed = HashMap::new();
         if let Some(hunk) = diff.hunk() {
             for (index, line) in hunk.lines.iter().enumerate() {
                 let line_index = match line {
                     Modification::Addition(addition) => DiffLineIndex {
                         old: None,
                         new: Some(addition.line_no),
                     },
                     Modification::Deletion(deletion) => DiffLineIndex {
                         old: Some(deletion.line_no),
                         new: None,
                     },
                     Modification::Context {
                         line: _,
                         line_no_old,
                         line_no_new,
                     } => DiffLineIndex {
                         old: Some(*line_no_old),
                         new: Some(*line_no_new),
                     },
                 };
                 indexed.insert(line_index, index as u32);
             }
         }
         Self { lines: indexed }
     }
     pub fn line(&self, index: DiffLineIndex) -> Option<u32> {
         self.lines.get(&index).copied()
     }
 }
 /// All comments per hunk, indexed by their merge location: start, line or end.
 #[derive(Clone, Debug)]
 pub struct HunkComments {
     /// All comments. Can be unsorted.
     comments: HashMap<MergeLocation, Vec<(EntryId, Comment<CodeLocation>)>>,
 }
 impl HunkComments {
     pub fn new(diff: &HunkDiff, comments: Vec<(EntryId, Comment<CodeLocation>)>) -> Self {
         let mut line_comments: HashMap<MergeLocation, Vec<(EntryId, Comment<CodeLocation>)>> =
             HashMap::new();
         let indexed = IndexedDiffLines::new(diff);
         for comment in comments {
             let line = if let Some(location) = comment.1.location() {
                 if let Some(hunk) = diff.hunk() {
                     let ranges = DiffLineRanges::from(hunk);
                     let index = DiffLineIndex::from(location);
                     if index.is_start_of(&ranges) {
                         MergeLocation::Start
                     } else if index.is_end_of(&ranges) {
                         MergeLocation::End
                     } else {
                         let mut line = indexed
                             .line(index.clone())
                             .map(|line| MergeLocation::Line(line as usize));
                         // TODO(erikli): Properly fix index lookup rules for addition:
                         // old line number need to be ignored.
                         if line.is_none() {
                             line = indexed
                                 .line(DiffLineIndex { old: None, ..index })
                                 .map(|line| MergeLocation::Line(line as usize))
                         }
                         line.unwrap_or_default()
                     }
                 } else {
                     MergeLocation::Unknown
                 }
             } else {
                 MergeLocation::Unknown
             };
             if let Some(comments) = line_comments.get_mut(&line) {
                 comments.push(comment.clone());
             } else {
                 line_comments.insert(line, vec![comment.clone()]);
             }
         }
         Self {
             comments: line_comments,
         }
     }
     pub fn all(&self) -> &HashMap<MergeLocation, Vec<(EntryId, Comment<CodeLocation>)>> {
         &self.comments
     }
     pub fn is_empty(&self) -> bool {
         self.comments.is_empty()
     }
     pub fn len(&self) -> usize {
         self.comments.values().fold(0_usize, |mut count, comments| {
             count += comments.len();
             count
         })
     }
 }
 /// A [`HunkItem`] that can be rendered. Hunk items are indexed sequentially and
 /// provide access to the underlying hunk type.
 #[derive(Clone)]
 pub struct HunkItem<'a> {
     /// The underlying hunk type and its current state (accepted / rejected).
     pub diff: HunkDiff,
     /// Raw or highlighted hunk lines. Highlighting is expensive and needs to be asynchronously.
     /// Therefor, a hunks' lines need to stored separately.
     pub lines: Blobs<Vec<Line<'a>>>,
     /// A hunks' comments, indexed by line.
     pub comments: HunkComments,
 }
 impl From<(&Repository, &Review, &HunkDiff)> for HunkItem<'_> {
     fn from(value: (&Repository, &Review, &HunkDiff)) -> Self {
         let (repo, review, item) = value;
         let hi = Highlighter::default();
         // TODO(erikli): Start with raw, non-highlighted lines and
         // move highlighting to separate task / thread, e.g. here:
         // `let lines = blobs.raw()`
         let blobs = item.clone().blobs(repo.raw());
         let lines = blobs.highlight(hi);
         // Filter comments and include them, if:
         // - comment has a code location
         // - comment path matches hunk path
         // - comment code location is inside hunk code range
         let comments = review
             .comments()
             .filter(|(_, comment)| {
                 if let Some(location) = comment.location() {
                     if location.path == *item.path() {
                         if let Some(hunk) = item.hunk() {
                             let ranges = DiffLineRanges::from(hunk);
                             let index = DiffLineIndex::from(location);
                             log::warn!("Checking comment {comment:?} at {index:?}");
                             return index.is_start_of(&ranges)
                                 || index.is_inside_of(&ranges)
                                 || index.is_end_of(&ranges);
                         } else {
                             return true;
                         }
                     }
                 }
                 false
             })
             .map(|(id, comment)| (*id, comment.clone()))
             .collect::<Vec<_>>();
         Self {
             diff: item.clone(),
             lines,
             comments: HunkComments::new(item, comments),
         }
     }
 }
 impl ToRow<3> for StatefulHunkItem<'_> {
     fn to_row(&self) -> [Cell<'_>; 3] {
         let build_stats_spans = |stats: &DiffStats| -> Vec<Span<'_>> {
             let mut cell = vec![];
             let comments = &self.inner().comments;
             if !comments.is_empty() {
                 cell.push(
                     span::default(&format!(" {} ", comments.len()))
                         .dim()
                         .reversed(),
                 );
                 cell.push(span::default(" "));
             }
             let (added, deleted) = match stats {
                 DiffStats::Hunk(stats) => (stats.added(), stats.deleted()),
                 DiffStats::File(stats) => (stats.additions, stats.deletions),
             };
             if added > 0 {
                 cell.push(span::default(&format!("+{added}")).light_green().dim());
             }
             if added > 0 && deleted > 0 {
                 cell.push(span::default(",").dim());
             }
             if deleted > 0 {
                 cell.push(span::default(&format!("-{deleted}")).light_red().dim());
             }
             cell
         };
         match &self.inner().diff {
             HunkDiff::Added {
                 path,
                 header: _,
                 new: _,
                 hunk,
                 _stats: _,
             } => {
                 let stats = hunk.as_ref().map(HunkStats::from).unwrap_or_default();
                 let stats_cell = [
                     build_stats_spans(&DiffStats::Hunk(stats)),
                     [span::default(" A ").bold().light_green().dim()].to_vec(),
                 ]
                 .concat();
                 [
                     Line::from(ui::span::hunk_state(self.state()))
                         .right_aligned()
                         .into(),
                     Line::from(ui::span::pretty_path(path, false, false)).into(),
                     Line::from(stats_cell).right_aligned().into(),
                 ]
             }
             HunkDiff::Modified {
                 path,
                 header: _,
                 old: _,
                 new: _,
                 hunk,
                 _stats: _,
             } => {
                 let stats = hunk.as_ref().map(HunkStats::from).unwrap_or_default();
                 let stats_cell = [
                     build_stats_spans(&DiffStats::Hunk(stats)),
                     [span::default(" M ").bold().light_yellow().dim()].to_vec(),
                 ]
                 .concat();
                 [
                     Line::from(ui::span::hunk_state(self.state()))
                         .right_aligned()
                         .into(),
                     Line::from(ui::span::pretty_path(path, false, false)).into(),
                     Line::from(stats_cell).right_aligned().into(),
                 ]
             }
             HunkDiff::Deleted {
                 path,
                 header: _,
                 old: _,
                 hunk,
                 _stats: _,
             } => {
                 let stats = hunk.as_ref().map(HunkStats::from).unwrap_or_default();
                 let stats_cell = [
                     build_stats_spans(&DiffStats::Hunk(stats)),
                     [span::default(" D ").bold().light_red().dim()].to_vec(),
                 ]
                 .concat();
                 [
                     Line::from(ui::span::hunk_state(self.state()))
                         .right_aligned()
                         .into(),
                     Line::from(ui::span::pretty_path(path, false, false)).into(),
                     Line::from(stats_cell).right_aligned().into(),
                 ]
             }
             HunkDiff::Copied { copied } => {
                 let stats = copied.diff.stats().copied().unwrap_or_default();
                 let stats_cell = [
                     build_stats_spans(&DiffStats::File(stats)),
                     [span::default(" CP ").bold().light_blue().dim()].to_vec(),
                 ]
                 .concat();
                 [
                     Line::from(ui::span::hunk_state(self.state()))
                         .right_aligned()
                         .into(),
                     Line::from(ui::span::pretty_path(&copied.new_path, false, false)).into(),
                     Line::from(stats_cell).right_aligned().into(),
                 ]
             }
             HunkDiff::Moved { moved } => {
                 let stats = moved.diff.stats().copied().unwrap_or_default();
                 let stats_cell = [
                     build_stats_spans(&DiffStats::File(stats)),
                     [span::default(" MV ").bold().light_blue().dim()].to_vec(),
                 ]
                 .concat();
                 [
                     Line::from(ui::span::hunk_state(self.state()))
                         .right_aligned()
                         .into(),
                     Line::from(ui::span::pretty_path(&moved.new_path, false, false)).into(),
                     Line::from(stats_cell).right_aligned().into(),
                 ]
             }
             HunkDiff::EofChanged {
                 path,
                 header: _,
                 old: _,
                 new: _,
                 _eof: _,
             } => [
                 Line::from(ui::span::hunk_state(self.state()))
                     .right_aligned()
                     .into(),
                 Line::from(ui::span::pretty_path(path, false, false)).into(),
                 Line::from(span::default("EOF ").light_blue())
                     .right_aligned()
                     .into(),
             ],
             HunkDiff::ModeChanged {
                 path,
                 header: _,
                 old: _,
                 new: _,
             } => [
                 Line::from(ui::span::hunk_state(self.state()))
                     .right_aligned()
                     .into(),
                 Line::from(ui::span::pretty_path(path, false, false)).into(),
                 Line::from(span::default("FM ").light_blue())
                     .right_aligned()
                     .into(),
             ],
         }
     }
 }
 impl<'a> HunkItem<'a> {
     pub fn header(&self) -> Vec<Column<'a>> {
         let comment_tag = if !self.comments.is_empty() {
             let count = self.comments.len();
             if count == 1 {
                 span::default(" 1 comment ").dim().reversed()
             } else {
                 span::default(&format!(" {count} comments "))
                     .dim()
                     .reversed()
             }
         } else {
             span::blank()
         };
         match &self.diff {
             HunkDiff::Added {
                 path,
                 header: _,
                 new: _,
                 hunk: _,
                 _stats: _,
             } => {
                 let path = Line::from(ui::span::pretty_path(path, false, true));
                 let header = [
                     Column::new("", Constraint::Length(0)),
                     Column::new(path.clone(), Constraint::Length(path.width() as u16)),
                     Column::new(
                         Line::from(
                             [
                                 comment_tag,
                                 span::default(" "),
                                 span::default(" added ").light_green().dim().reversed(),
                             ]
                             .to_vec(),
                         )
                         .right_aligned(),
                         Constraint::Fill(1),
                     ),
                 ];
                 header.to_vec()
             }
             HunkDiff::Modified {
                 path,
                 header: _,
                 old: _,
                 new: _,
                 hunk: _,
                 _stats: _,
             } => {
                 let path = Line::from(ui::span::pretty_path(path, false, true));
                 let header = [
                     Column::new("", Constraint::Length(0)),
                     Column::new(path.clone(), Constraint::Length(path.width() as u16)),
                     Column::new(
                         Line::from(
                             [
                                 comment_tag,
                                 span::default(" "),
                                 span::default(" modified ").light_yellow().dim().reversed(),
                             ]
                             .to_vec(),
                         )
                         .right_aligned(),
                         Constraint::Fill(1),
                     ),
                 ];
                 header.to_vec()
             }
             HunkDiff::Deleted {
                 path,
                 header: _,
                 old: _,
                 hunk: _,
                 _stats: _,
             } => {
                 let path = Line::from(ui::span::pretty_path(path, true, true));
                 let header = [
                     Column::new("", Constraint::Length(0)),
                     Column::new(path.clone(), Constraint::Length(path.width() as u16)),
                     Column::new(
                         Line::from(
                             [
                                 comment_tag,
                                 span::default(" "),
                                 span::default(" deleted ").light_red().dim().reversed(),
                             ]
                             .to_vec(),
                         )
                         .right_aligned(),
                         Constraint::Fill(1),
                     ),
                 ];
                 header.to_vec()
             }
             HunkDiff::Copied { copied } => {
                 let path = Line::from(
                     [
                         ui::span::pretty_path(&copied.old_path, false, true),
                         [span::default(" -> ")].to_vec(),
                         ui::span::pretty_path(&copied.new_path, false, true),
                     ]
                     .concat()
                     .to_vec(),
                 );
                 let header = [
                     Column::new("", Constraint::Length(0)),
                     Column::new(path.clone(), Constraint::Length(path.width() as u16)),
                     Column::new(
                         span::default(" copied ")
                             .light_blue()
                             .dim()
                             .reversed()
                             .into_right_aligned_line(),
                         Constraint::Fill(1),
                     ),
                 ];
                 header.to_vec()
             }
             HunkDiff::Moved { moved } => {
                 let path = Line::from(
                     [
                         ui::span::pretty_path(&moved.old_path, false, true),
                         [span::default(" -> ")].to_vec(),
                         ui::span::pretty_path(&moved.new_path, false, true),
                     ]
                     .concat()
                     .to_vec(),
                 );
                 let header = [
                     Column::new("", Constraint::Length(0)),
                     Column::new(path.clone(), Constraint::Length(path.width() as u16)),
                     Column::new(
                         span::default(" moved ")
                             .light_blue()
                             .dim()
                             .reversed()
                             .into_right_aligned_line(),
                         Constraint::Fill(1),
                     ),
                 ];
                 header.to_vec()
             }
             HunkDiff::EofChanged {
                 path,
                 header: _,
                 old: _,
                 new: _,
                 _eof: _,
             } => {
                 let path = Line::from(ui::span::pretty_path(path, false, true));
                 let header = [
                     Column::new("", Constraint::Length(0)),
                     Column::new(path.clone(), Constraint::Length(path.width() as u16)),
                     Column::new(
                         span::default(" eof ")
                             .dim()
                             .reversed()
                             .into_right_aligned_line(),
                         Constraint::Fill(1),
                     ),
                 ];
                 header.to_vec()
             }
             HunkDiff::ModeChanged {
                 path,
                 header: _,
                 old: _,
                 new: _,
             } => {
                 let path = Line::from(ui::span::pretty_path(path, false, true));
                 let header = [
                     Column::new("", Constraint::Length(0)),
                     Column::new(path.clone(), Constraint::Length(path.width() as u16)),
                     Column::new(
                         span::default(" mode ")
                             .dim()
                             .reversed()
                             .into_right_aligned_line(),
                         Constraint::Length(6),
                     ),
                 ];
                 header.to_vec()
             }
         }
     }
     pub fn hunk_text(&'a self) -> Option<Text<'a>> {
         match &self.diff {
             HunkDiff::Added { hunk, .. }
             | HunkDiff::Modified { hunk, .. }
             | HunkDiff::Deleted { hunk, .. } => {
                 let mut lines = hunk
                     .as_ref()
                     .map(|hunk| Text::from(hunk.to_text(&self.lines)));
                 lines = lines.map(|lines| {
                     let divider = span::default(&"─".to_string().repeat(500)).gray().dim();
                     let mut merge = HashMap::new();
                     for (line, comments) in self.comments.all() {
                         merge.insert(
                             line.clone(),
                             comments
                                 .iter()
                                 .enumerate()
                                 .map(|(idx, comment)| {
                                     let timestamp =
                                         span::timestamp(&format::timestamp(&comment.1.timestamp()));
                                     let author =
                                         span::alias(&format::did(&Did::from(comment.1.author())));
                                     let mut rendered = vec![];
                                     // Only add top divider for the first comment
                                     if idx == 0 {
                                         rendered.push(Line::from([divider.clone()].to_vec()));
                                     }
                                     // Add comment body
                                     rendered.extend(comment.1.body().lines().map(|line| {
                                         Line::from([span::default(line).gray()].to_vec())
                                     }));
                                     // Add metadata
                                     rendered.push(
                                         Line::from(
                                             [timestamp, span::default(" by ").dim(), author]
                                                 .to_vec(),
                                         )
                                         .right_aligned(),
                                     );
                                     // Add bottom divider
                                     rendered.push(Line::from([divider.clone()].to_vec()));
                                     rendered
                                 })
                                 .collect(),
                         );
                     }
                     let merged = LineMerger::new(lines.lines).merge(merge, None);
                     Text::from(merged)
                 });
                 lines
             }
             _ => None,
         }
     }
 }
 impl Debug for HunkItem<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("HunkItem")
             .field("inner", &self.diff)
             .field("comments", &self.comments)
             .finish()
     }
 }
 #[derive(Clone, Debug)]
 pub struct StatefulHunkItem<'a>(HunkItem<'a>, HunkState);
 impl<'a> StatefulHunkItem<'a> {
     pub fn new(inner: HunkItem<'a>, state: HunkState) -> Self {
         Self(inner, state)
     }
     pub fn inner(&self) -> &HunkItem<'a> {
         &self.0
     }
     pub fn state(&self) -> &HunkState {
         &self.1
     }
     pub fn update_state(&mut self, state: &HunkState) {
         self.1 = state.clone();
     }
 }
 pub struct HighlightedLine<'a>(Line<'a>);
 impl<'a> From<Line<'a>> for HighlightedLine<'a> {
     fn from(highlighted: Line<'a>) -> Self {
         let converted = highlighted.to_string().into_text().unwrap().lines;
         Self(converted.first().cloned().unwrap_or_default())
     }
 }
 impl<'a> From<HighlightedLine<'a>> for Line<'a> {
     fn from(val: HighlightedLine<'a>) -> Self {
         val.0
     }
 }
 /// Types that can be rendered as texts.
 pub trait ToText<'a> {
     /// The output of the render process.
     type Output: Into<Text<'a>>;
     /// Context that can be passed down from parent objects during rendering.
     type Context;
     /// Render to pretty diff output.
     fn to_text(&'a self, context: &Self::Context) -> Self::Output;
 }
 impl<'a> ToText<'a> for HunkHeader {
     type Output = Line<'a>;
     type Context = ();
     fn to_text(&self, _context: &Self::Context) -> Self::Output {
         Line::from(
             [
                 span::default(&format!(
                     "@@ -{},{} +{},{} @@",
                     self.old_line_no, self.old_size, self.new_line_no, self.new_size,
                 ))
                 .gray(),
                 span::default(" "),
                 span::default(String::from_utf8_lossy(&self.text).as_ref()),
             ]
             .to_vec(),
         )
     }
 }
 impl<'a> ToText<'a> for Modification {
     type Output = Line<'a>;
     type Context = Blobs<Vec<Line<'a>>>;
     fn to_text(&'a self, blobs: &Blobs<Vec<Line<'a>>>) -> Self::Output {
         let line = match self {
             Modification::Deletion(diff::Deletion { line, line_no }) => {
                 if let Some(lines) = &blobs.old.as_ref() {
                     lines[*line_no as usize - 1].clone()
                 } else {
                     Line::raw(String::from_utf8_lossy(line.as_bytes()))
                 }
             }
             Modification::Addition(diff::Addition { line, line_no }) => {
                 if let Some(lines) = &blobs.new.as_ref() {
                     lines[*line_no as usize - 1].clone()
                 } else {
                     Line::raw(String::from_utf8_lossy(line.as_bytes()))
                 }
             }
             Modification::Context {
                 line, line_no_new, ..
             } => {
                 // Nb. we can check in the old or the new blob, we choose the new.
                 if let Some(lines) = &blobs.new.as_ref() {
                     lines[*line_no_new as usize - 1].clone()
                 } else {
                     Line::raw(String::from_utf8_lossy(line.as_bytes()))
                 }
             }
         };
         HighlightedLine::from(line).into()
     }
 }
 impl<'a> ToText<'a> for Hunk<Modification> {
     type Output = Vec<Line<'a>>;
     type Context = Blobs<Vec<Line<'a>>>;
     fn to_text(&'a self, blobs: &Self::Context) -> Self::Output {
         let mut lines: Vec<Line<'a>> = vec![];
         let default_dark = Color::Rgb(20, 20, 20);
         let positive_light = Color::Rgb(10, 60, 20);
         let positive_dark = Color::Rgb(10, 30, 20);
         let negative_light = Color::Rgb(60, 10, 20);
         let negative_dark = Color::Rgb(30, 10, 20);
         if let Ok(header) = HunkHeader::from_bytes(self.header.as_bytes()) {
             lines.push(Line::from(
                 [
                     span::default(&format!(
                         "@@ -{},{} +{},{} @@",
                         header.old_line_no, header.old_size, header.new_line_no, header.new_size,
                     ))
                     .gray()
                     .dim(),
                     span::default(" "),
                     span::default(String::from_utf8_lossy(&header.text).as_ref())
                         .gray()
                         .dim(),
                 ]
                 .to_vec(),
             ))
         }
         for line in &self.lines {
             match line {
                 Modification::Addition(a) => {
                     lines.push(Line::from(
                         [
                             [
                                 span::positive(&format!("{:<5}", ""))
                                     .bg(positive_light)
                                     .dim(),
                                 span::positive(&format!("{:<5}", &a.line_no.to_string()))
                                     .bg(positive_light)
                                     .dim(),
                                 span::positive(" + ").bg(positive_dark).dim(),
                             ]
                             .to_vec(),
                             line.to_text(blobs)
                                 .spans
                                 .into_iter()
                                 .map(|span| span.bg(positive_dark))
                                 .collect::<Vec<_>>(),
                             [span::positive(&format!("{:<500}", "")).bg(positive_dark)].to_vec(),
                         ]
                         .concat(),
                     ));
                 }
                 Modification::Deletion(d) => {
                     lines.push(Line::from(
                         [
                             [
                                 span::negative(&format!("{:<5}", &d.line_no.to_string()))
                                     .bg(negative_light)
                                     .dim(),
                                 span::negative(&format!("{:<5}", ""))
                                     .bg(negative_light)
                                     .dim(),
                                 span::negative(" - ").bg(negative_dark).dim(),
                             ]
                             .to_vec(),
                             line.to_text(blobs)
                                 .spans
                                 .into_iter()
                                 .map(|span| span.bg(negative_dark))
                                 .collect::<Vec<_>>(),
                             [span::positive(&format!("{:<500}", "")).bg(negative_dark)].to_vec(),
                         ]
                         .concat(),
                     ));
                 }
                 Modification::Context {
                     line_no_old,
                     line_no_new,
                     ..
                 } => {
                     lines.push(Line::from(
                         [
                             [
                                 span::default(&format!("{:<5}", &line_no_old.to_string()))
                                     .bg(default_dark)
                                     .gray()
                                     .dim(),
                                 span::default(&format!("{:<5}", &line_no_new.to_string()))
                                     .bg(default_dark)
                                     .gray()
                                     .dim(),
                                 span::default(&format!("{:<3}", "")),
                             ]
                             .to_vec(),
                             line.to_text(blobs).spans,
                         ]
                         .concat(),
                     ));
                 }
             }
         }
         lines
     }
 }
 #[cfg(test)]
 mod tests {
     use std::path::PathBuf;
     use std::str::FromStr;
     use anyhow::Result;
     use radicle::cob::patch;
     use crate::test;
     use crate::ui::items::filter::DidFilter;
     use crate::ui::items::patch::filter::PatchFilter;
     use super::*;
     #[test]
     fn patch_filter_with_all_should_succeed() -> Result<()> {
         let search = r#"state=open author=(did:key:z6MkkpTPzcq1ybmjQyQpyre15JUeMvZY6toxoZVpLZ8YarsB or did:key:z6Mku8hpprWTmCv3BqkssCYDfr2feUdyLSUnycVajFo9XVAx) cli"#;
         let expected = PatchFilter::And(vec![
             PatchFilter::State(patch::Status::Open),
             PatchFilter::Author(DidFilter::Or(vec![
                 Did::from_str("did:key:z6MkkpTPzcq1ybmjQyQpyre15JUeMvZY6toxoZVpLZ8YarsB")?,
                 Did::from_str("did:key:z6Mku8hpprWTmCv3BqkssCYDfr2feUdyLSUnycVajFo9XVAx")?,
             ])),
             PatchFilter::Search("cli".to_string()),
         ]);
         let actual = PatchFilter::from_str(search)?;
         assert_eq!(expected, actual);
         Ok(())
     }
     #[test]
     fn patch_filter_with_all_shuffled_should_succeed() -> Result<()> {
         let search =
             r#"author=did:key:z6MkkpTPzcq1ybmjQyQpyre15JUeMvZY6toxoZVpLZ8YarsB state=open cli"#;
         let expected = PatchFilter::And(vec![
             PatchFilter::Author(DidFilter::Single(Did::from_str(
                 "did:key:z6MkkpTPzcq1ybmjQyQpyre15JUeMvZY6toxoZVpLZ8YarsB",
             )?)),
             PatchFilter::State(patch::Status::Open),
             PatchFilter::Search("cli".to_string()),
         ]);
         let actual = PatchFilter::from_str(search)?;
         assert_eq!(expected, actual);
         Ok(())
     }
     #[test]
     fn diff_line_index_checks_ranges_correctly() -> Result<()> {
         let commit = Oid::from_str("a32c4b93e2573fd83b15ac1ad6bf1317dc8fd760").unwrap();
         let path = PathBuf::from_str("main.rs").unwrap();
         // --------------------------------------------------------------------
         // At the top.
         // --------------------------------------------------------------------
         // @@ -3,8 +3,7 @@
         // 3   3     // or if you prefer to use your keyboard, you can use the "Ctrl + Enter"
         // 4   4     // shortcut.
         // 5   5
         // 6       - // This code is editable, feel free to hack it!
         // 7       - // You can always return to the original code by clicking the "Reset" button ->
         //     6   + // This is still a comment.
         // --------------------------------------------------------------------
         // In the middle.
         // --------------------------------------------------------------------
         // 8   7
         // 9   8     // This is the main function.
         // 10  9     fn main() {
         // ---------------------------------------------------------------------
         // At the end.
         // ---------------------------------------------------------------------
         let diff = test::fixtures::simple_modified_hunk_diff(&path, commit)?;
         let ranges = DiffLineRanges::from(diff.hunk().unwrap());
         let start = CodeLocation {
             commit,
             path: path.clone(),
             old: Some(CodeRange::Lines { range: 3..12 }),
             new: Some(CodeRange::Lines { range: 3..11 }),
         };
         assert!(DiffLineIndex::from(&start).is_start_of(&ranges));
         assert!(!DiffLineIndex::from(&start).is_inside_of(&ranges));
         assert!(!DiffLineIndex::from(&start).is_end_of(&ranges));
         let inside = CodeLocation {
             commit,
             path: path.clone(),
             old: Some(CodeRange::Lines { range: 3..8 }),
             new: Some(CodeRange::Lines { range: 3..7 }),
         };
         assert!(DiffLineIndex::from(&inside).is_inside_of(&ranges));
         assert!(!DiffLineIndex::from(&inside).is_start_of(&ranges));
         assert!(!DiffLineIndex::from(&inside).is_end_of(&ranges));
         let end = CodeLocation {
             commit,
             path: path.clone(),
             old: Some(CodeRange::Lines { range: 3..11 }),
             new: Some(CodeRange::Lines { range: 3..10 }),
         };
         assert!(DiffLineIndex::from(&end).is_end_of(&ranges));
         assert!(!DiffLineIndex::from(&end).is_start_of(&ranges));
         assert!(!DiffLineIndex::from(&end).is_inside_of(&ranges));
         let outside = CodeLocation {
             commit,
             path: path.clone(),
             old: Some(CodeRange::Lines { range: 125..127 }),
             new: Some(CodeRange::Lines { range: 125..128 }),
         };
         assert!(!DiffLineIndex::from(&outside).is_start_of(&ranges));
         assert!(!DiffLineIndex::from(&outside).is_inside_of(&ranges));
         assert!(!DiffLineIndex::from(&outside).is_end_of(&ranges));
         Ok(())
     }
     #[test]
     fn hunk_comments_on_modified_simple_are_inserted_correctly() -> Result<()> {
         let alice = test::fixtures::node_with_repo();
         let commit = Oid::from_str("a32c4b93e2573fd83b15ac1ad6bf1317dc8fd760").unwrap();
         let path = PathBuf::from_str("main.rs").unwrap();
         // --------------------------------------------------------------------
         // At the top.
         // --------------------------------------------------------------------
         // @@ -3,8 +3,7 @@
         // 3   3     // or if you prefer to use your keyboard, you can use the "Ctrl + Enter"
         // 4   4     // shortcut.
         // 5   5
         // 6       - // This code is editable, feel free to hack it!
         // 7       - // You can always return to the original code by clicking the "Reset" button ->
         //     6   + // This is still a comment.
         // --------------------------------------------------------------------
         // In the middle.
         // --------------------------------------------------------------------
         // 8   7
         // 9   8     // This is the main function.
         // 10  9     fn main() {
         // ---------------------------------------------------------------------
         // At the end.
         // ---------------------------------------------------------------------
         let diff = test::fixtures::simple_modified_hunk_diff(&path, commit)?;
         let top = (
             Oid::from_str("05ac6202655dcde6c2613702fec07c2e2fe8f382").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "At the top.".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 3..12 }),
                     new: Some(CodeRange::Lines { range: 3..11 }),
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let middle = (
             Oid::from_str("2d09104bf2d6ad328aa72594b679d2d6c5a61865").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "In the middle.".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 3..8 }),
                     new: Some(CodeRange::Lines { range: 3..7 }),
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let end = (
             Oid::from_str("8280317b308ba1bf2cef04533efb15d920431e86").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "At the end.".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 3..11 }),
                     new: Some(CodeRange::Lines { range: 3..10 }),
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let comments = {
             let comments = [top.clone(), middle.clone(), end.clone()];
             HunkComments::new(&diff, comments.to_vec())
         };
         for expected in [
             (top, MergeLocation::Start),
             (middle, MergeLocation::Line(5)),
             (end, MergeLocation::End),
         ] {
             let (line, expected) = (expected.1, expected.0);
             let actual = comments.all().get(&line);
             assert_ne!(actual, None, "No comment found at {line:?}");
             let actual = actual.unwrap().first().unwrap();
             assert_eq!(actual.0, expected.0);
         }
         Ok(())
     }
     #[test]
     fn hunk_comments_on_modified_complex_are_inserted_correctly() -> Result<()> {
         let alice = test::fixtures::node_with_repo();
         let commit = Oid::from_str("a32c4b93e2573fd83b15ac1ad6bf1317dc8fd760").unwrap();
         let path = PathBuf::from_str("main.rs").unwrap();
         // --------------------------------------------------------------------
         // At the top.
         // --------------------------------------------------------------------
         // @@ -1,17 +1,15 @@
         // 1       - use radicle::issue::IssueId;
         // 2       - use tui::ui::state::ItemState;
         // 3       - use tui::SelectionExit;
         // --------------------------------------------------------------------
         // After deletion.
         // --------------------------------------------------------------------
         // 4   1     use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection};
         // 5   2     use tuirealm::event::{Event, Key, KeyEvent};
         // 6   3     use tuirealm::{MockComponent, NoUserEvent};
         // 7   4
         // 8   5     use radicle_tui as tui;
         // 9   6
         //     7   + use tui::ui::state::ItemState;
         // 10  8     use tui::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer};
         // 11  9     use tui::ui::widget::context::{ContextBar, Shortcuts};
         // 12  10    use tui::ui::widget::list::PropertyList;
         // 13      -
         // 14  11    use tui::ui::widget::Widget;
         //     12  + use tui::{Id, SelectionExit};
         // 15  13
         // 16  14    use super::ui::{IdSelect, OperationSelect};
         // --------------------------------------------------------------------
         // Before last line.
         // --------------------------------------------------------------------
         // 17  15    use super::{IssueOperation, Message};
         let diff = test::fixtures::complex_modified_hunk_diff(&path, commit)?;
         let top = (
             Oid::from_str("05ac6202655dcde6c2613702fec07c2e2fe8f382").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "At the top.".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 1..18 }),
                     new: Some(CodeRange::Lines { range: 1..17 }),
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let after_deletion = (
             Oid::from_str("2d09104bf2d6ad328aa72594b679d2d6c5a61865").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "After deletion.".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 1..4 }),
                     new: None,
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let before_last_line = (
             Oid::from_str("60972bca0c9e686e76b0a5123acb3c8c60c38b1e").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "Before last line".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 1..17 }),
                     new: Some(CodeRange::Lines { range: 1..15 }),
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let comments = {
             let comments = [
                 top.clone(),
                 after_deletion.clone(),
                 before_last_line.clone(),
             ];
             HunkComments::new(&diff, comments.to_vec())
         };
         for expected in [
             (top, MergeLocation::Start),
             (after_deletion, MergeLocation::Line(2)),
             (before_last_line, MergeLocation::Line(17)),
         ] {
             let (line, expected) = (expected.1, expected.0);
             let actual = comments.all().get(&line);
             assert_ne!(actual, None, "No comment found at {line:?}");
             let actual = actual.unwrap().first().unwrap();
             assert_eq!(actual.0, expected.0);
         }
         Ok(())
     }
     #[test]
     fn hunk_comments_on_deleted_simple_are_inserted_correctly() -> Result<()> {
         let alice = test::fixtures::node_with_repo();
         let commit = Oid::from_str("a32c4b93e2573fd83b15ac1ad6bf1317dc8fd760").unwrap();
         let path = PathBuf::from_str("README.md").unwrap();
         // --------------------------------------------------------------------
         // At the top.
         // --------------------------------------------------------------------
         // @@ -1,1 +0,0 @@
         //  -TBD
         // --------------------------------------------------------------------
         // At the end.
         // --------------------------------------------------------------------
         let diff = test::fixtures::deleted_hunk_diff(&path, commit)?;
         let top = (
             Oid::from_str("05ac6202655dcde6c2613702fec07c2e2fe8f382").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "At the top.".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 1..3 }),
                     new: Some(CodeRange::Lines { range: 0..1 }),
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let end = (
             Oid::from_str("8280317b308ba1bf2cef04533efb15d920431e86").unwrap(),
             Comment::new(
                 *alice.node.signer.public_key(),
                 "At the end.".to_string(),
                 None,
                 Some(CodeLocation {
                     commit,
                     path: path.clone(),
                     old: Some(CodeRange::Lines { range: 1..2 }),
                     new: None,
                 }),
                 vec![],
                 Timestamp::from_secs(0),
             ),
         );
         let comments = {
             let comments = [top.clone(), end.clone()];
             HunkComments::new(&diff, comments.to_vec())
         };
         for expected in [(top, MergeLocation::Start), (end, MergeLocation::End)] {
             let (line, expected) = (expected.1, expected.0);
             let actual = comments.all().get(&line);
             assert_ne!(actual, None, "No comment found at {line:?}");
             let actual = actual.unwrap().first().unwrap();
             assert_eq!(actual.0, expected.0);
         }
         Ok(())
     }
 }