pub mod issue; pub mod notification; pub mod patch; use std::collections::HashMap; use std::fmt::Debug; use radicle::cob::thread::{Comment, CommentId}; use radicle::cob::{ObjectId, Timestamp}; use radicle::identity::Did; use radicle::issue::{Issue, IssueId}; use radicle::node::{Alias, AliasStore, NodeId}; use radicle::Profile; use ratatui::prelude::*; use ratatui::style::Stylize; use tui_tree_widget::TreeItem; use radicle_tui as tui; use tui::ui::span; use tui::ui::ToTree; use super::format; pub mod filter { use std::fmt::{self, Write}; use std::str::FromStr; use nom::bytes::complete::{tag_no_case, take}; use nom::character::complete::{char, multispace0}; use nom::combinator::map; use nom::multi::separated_list1; use nom::sequence::delimited; use nom::{IResult, Parser}; 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 { fn matches(&self, item: &T) -> bool; } #[derive(Debug, Clone, PartialEq, Eq)] pub enum DidFilter { Single(Did), Or(Vec), } impl fmt::Display for DidFilter { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { DidFilter::Single(did) => write!(f, "{did}")?, DidFilter::Or(dids) => { let mut it = dids.iter().peekable(); f.write_char('(')?; while let Some(did) = it.next() { write!(f, "{did}")?; if it.peek().is_none() { write!(f, " or ")?; } } f.write_char(')')?; } } Ok(()) } } 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, ))), } } pub fn parse_did_or(input: &str) -> IResult<&str, DidFilter> { map( delimited( (multispace0, char('('), multispace0), separated_list1( delimited(multispace0, tag_no_case("or"), multispace0), take(56_usize), ), (multispace0, char(')'), multispace0), ), |dids: Vec<&str>| { DidFilter::Or( dids.iter() .filter_map(|did| Did::from_str(did).ok()) .collect::>(), ) }, ) .parse(input) } } pub trait HasId { fn id(&self) -> ObjectId; } #[derive(Clone, Debug, PartialEq, Eq)] pub struct AuthorItem { pub nid: Option, pub human_nid: Option, pub alias: Option, pub you: bool, } impl AuthorItem { pub fn new(nid: Option, profile: &Profile) -> Self { let alias = match nid { Some(nid) => profile.alias(&nid), None => None, }; let you = nid.map(|nid| nid == *profile.id()).unwrap_or_default(); let human_nid = nid.map(|nid| format::did(&Did::from(nid))); Self { nid, human_nid, alias, you, } } } /// A `CommentItem` represents a comment COB and is constructed from an `Issue` and /// a `Comment`. #[derive(Clone, Debug)] pub struct CommentItem { /// Comment OID. pub id: CommentId, /// Author of this comment. pub author: AuthorItem, /// The content of this comment. pub body: String, /// Reactions to this comment. pub reactions: Vec, /// Time when patch was opened. pub timestamp: Timestamp, /// The parent OID if this is a reply. pub reply_to: Option, /// Replies to this comment. pub replies: Vec, } impl CommentItem { pub fn new(profile: &Profile, issue: (IssueId, Issue), comment: (CommentId, Comment)) -> Self { let (issue_id, issue) = issue; let (comment_id, comment) = comment; Self { id: comment_id, author: AuthorItem::new(Some(NodeId::from(*comment.author().0)), profile), body: comment.body().to_string(), reactions: comment.reactions().iter().map(|r| r.0.emoji()).collect(), timestamp: comment.timestamp(), reply_to: comment.reply_to(), replies: issue .thread() .replies(&comment_id) .map(|(reply_id, reply)| { CommentItem::new( profile, (issue_id, issue.clone()), (*reply_id, reply.clone()), ) }) .collect(), } } pub fn accumulated_reactions(&self) -> Vec<(char, usize)> { let mut accumulated: HashMap = HashMap::new(); for reaction in &self.reactions { if let Some(count) = accumulated.get_mut(reaction) { *count = count.saturating_add(1); } else { accumulated.insert(*reaction, 1_usize); } } let mut sorted = accumulated.into_iter().collect::>(); sorted.sort(); sorted } pub fn path_to(&self, target_id: &CommentId, path: &mut Vec) -> bool { path.push(self.id); if self.id == *target_id { return true; } for reply in &self.replies { if reply.path_to(target_id, path) { return true; } } path.pop(); false } } impl ToTree for CommentItem { fn rows(&self) -> Vec> { let children = self.replies.iter().flat_map(CommentItem::rows).collect(); 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 action = if self.reply_to.is_none() { "opened" } else { "commented" }; let timestamp = span::timestamp(&format::timestamp(&self.timestamp)); let text = Text::from(Line::from( [author, " ".into(), action.into(), " ".into(), timestamp].to_vec(), )); let item = TreeItem::new(self.id.to_string(), text, children) .expect("Identifiers need to be unique"); vec![item] } }