c864888 lib: Introduce features 'realm' and 'flux' — radicle-tui

modified Cargo.toml

@@ -10,6 +10,11 @@ build = "build.rs"

 name = "rad-tui"
 path = "bin/main.rs"
 [features]
 default = ["flux"]
 realm = ["dep:tuirealm", "dep:tui-realm-stdlib"]
 flux = ["dep:tokio", "dep:tokio-stream"]
 [dependencies]
 anyhow = { version = "1" }
 inquire = { version = "0.6.2", default-features = false, features = ["termion", "editor"] }

@@ -26,7 +31,7 @@ timeago = { version = "0.4.1" }

 termion = { version = "3" }
 textwrap = { version = "0.16.0" }
 thiserror = { version = "1" }
 tokio = { version = "1.32.0", features = ["full"] }
 tokio-stream = { version = "0.1.14" }
 tuirealm = { version = "^1.9.0", default-features = false, features = ["termion", "ratatui", "derive"] }
 tui-realm-stdlib = { version = "1.3.1", default-features = false, features = ["termion", "ratatui"] }
 tokio = { version = "1.32.0", features = ["full"], optional = true }
 tokio-stream = { version = "0.1.14", optional = true }
 tuirealm = { version = "^1.9.0", default-features = false, features = ["termion", "ratatui", "derive"], optional = true }
 tui-realm-stdlib = { version = "1.3.1", default-features = false, features = ["termion", "ratatui"], optional = true }

modified bin/commands/inbox.rs

@@ -1,5 +1,12 @@

 #[path = "inbox/select.rs"]
 mod select;
 #[cfg(feature = "flux")]
 #[path = "inbox/flux.rs"]
 mod flux;
 #[cfg(feature = "realm")]
 #[path = "inbox/realm.rs"]
 mod realm;
 #[path = "inbox/common.rs"]
 mod common;
 use std::ffi::OsString;

@@ -7,13 +14,13 @@ use anyhow::anyhow;

 use radicle_tui as tui;
 use tui::cob::inbox::{self};
 use tui::{context, log, Window};
 use tui::common::cob::inbox::{self};
 use tui::common::context;
 use tui::common::log;
 use crate::terminal;
 use crate::terminal::args::{Args, Error, Help};
 pub const FPS: u64 = 60;
 pub const HELP: Help = Help {
     name: "inbox",
     description: "Terminal interfaces for notifications",

@@ -51,7 +58,7 @@ pub enum OperationName {

 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct SelectOptions {
     mode: select::Mode,
     mode: common::Mode,
     filter: inbox::Filter,
     sort_by: inbox::SortBy,
 }

@@ -78,8 +85,8 @@ impl Args for Options {

                     let val = val.to_str().unwrap_or_default();
                     select_opts.mode = match val {
                         "operation" => select::Mode::Operation,
                         "id" => select::Mode::Id,
                         "operation" => common::Mode::Operation,
                         "id" => common::Mode::Id,
                         unknown => anyhow::bail!("unknown mode '{}'", unknown),
                     };
                 }

@@ -121,7 +128,11 @@ impl Args for Options {

     }
 }
 #[cfg(feature = "realm")]
 pub fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()> {
     use tui::realm::Window;
     pub const FPS: u64 = 60;
     let (_, id) = radicle::rad::cwd()
         .map_err(|_| anyhow!("this command must be run in the context of a project"))?;

@@ -132,7 +143,7 @@ pub fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()>

             log::enable(context.profile(), "inbox", "select")?;
             let mut app = select::App::new(
             let mut app = realm::select::App::new(
                 context,
                 opts.mode.clone(),
                 opts.filter.clone(),

@@ -150,3 +161,25 @@ pub fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()>

     Ok(())
 }
 #[cfg(feature = "flux")]
 #[tokio::main]
 pub async fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()> {
     let (_, id) = radicle::rad::cwd()
         .map_err(|_| anyhow!("this command must be run in the context of a project"))?;
     match options.op {
         Operation::Select { opts } => {
             let profile = terminal::profile()?;
             let context = context::Context::new(profile, id)?;
             log::enable(context.profile(), "inbox", "select")?;
             let _ = flux::select::App::new(context, opts.filter.clone())
                 .run()
                 .await;
         }
     }
     Ok(())
 }

added bin/commands/inbox/common.rs

@@ -0,0 +1,10 @@

 /// The application's subject. It tells the application
 /// which widgets to render and which output to produce.
 ///
 /// Depends on CLI arguments given by the user.
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub enum Mode {
     Id,
     #[default]
     Operation,
 }

added bin/commands/inbox/flux.rs

@@ -0,0 +1,2 @@

+	`#[path = "flux/select.rs"]`
+	`pub mod select;`

added bin/commands/inbox/flux/select.rs

@@ -0,0 +1,102 @@

 #[path = "select/ui.rs"]
 mod ui;
 use anyhow::Result;
 use radicle::node::notifications::NotificationId;
 use radicle_tui as tui;
 use tui::common::cob::inbox::{self, Filter};
 use tui::common::context::Context;
 use tui::flux::store::{State, Store};
 use tui::flux::termination::{self, Interrupted};
 use tui::flux::ui::cob::NotificationItem;
 use tui::flux::ui::Frontend;
 use tui::Exit;
 use ui::ListPage;
 pub struct App {
     context: Context,
     _filter: Filter,
 }
 #[derive(Clone, Debug)]
 pub struct InboxState {
     notifications: Vec<NotificationItem>,
     selected: Option<NotificationId>,
 }
 impl TryFrom<&Context> for InboxState {
     type Error = anyhow::Error;
     fn try_from(context: &Context) -> Result<Self, Self::Error> {
         let notifications = inbox::all(context.repository(), context.profile())?;
         let mut items = vec![];
         for notif in &notifications {
             if let Ok(notif) = NotificationItem::try_from((context.repository(), notif)) {
                 items.push(notif);
             }
         }
         Ok(Self {
             notifications: items,
             selected: None,
         })
     }
 }
 pub enum Action {
     Exit,
     Select(NotificationId),
 }
 impl State<Action> for InboxState {
     type Exit = Exit<String>;
     fn tick(&self) {}
     fn handle_action(&mut self, action: Action) -> Option<Exit<String>> {
         match action {
             Action::Select(id) => {
                 self.selected = Some(id);
                 None
             }
             Action::Exit => Some(Exit { value: None }),
         }
     }
 }
 impl App {
     pub fn new(context: Context, filter: Filter) -> Self {
         Self {
             context,
             _filter: filter,
         }
     }
     pub async fn run(&self) -> Result<()> {
         let (terminator, mut interrupt_rx) = termination::create_termination();
         let (store, state_rx) = Store::<Action, InboxState>::new();
         let (frontend, action_rx) = Frontend::<Action>::new();
         let state = InboxState::try_from(&self.context)?;
         tokio::try_join!(
             store.main_loop(state, terminator, action_rx, interrupt_rx.resubscribe()),
             frontend.main_loop::<InboxState, ListPage>(state_rx, interrupt_rx.resubscribe()),
         )?;
         if let Ok(reason) = interrupt_rx.recv().await {
             match reason {
                 Interrupted::UserInt => {}
                 Interrupted::OsSigInt => println!("exited because of an os sig int"),
             }
         } else {
             println!("exited because of an unexpected error");
         }
         Ok(())
     }
 }

added bin/commands/inbox/flux/select/ui.rs

@@ -0,0 +1,228 @@

 use tokio::sync::mpsc::UnboundedSender;
 use termion::event::Key;
 use ratatui::backend::Backend;
 use ratatui::layout::{Constraint, Rect};
 use ratatui::widgets::Cell;
 use radicle_tui as tui;
 use tui::flux::ui::cob::NotificationItem;
 use tui::flux::ui::span;
 use tui::flux::ui::widget::{
     FooterProps, Render, Shortcut, Shortcuts, ShortcutsProps, Table, TableProps, Widget,
 };
 use super::{Action, InboxState};
 pub struct ListPage {
     /// Action sender
     pub action_tx: UnboundedSender<Action>,
     /// notification widget
     notifications: Notifications,
     /// Shortcut widget
     shortcuts: Shortcuts<Action>,
 }
 impl Widget<InboxState, Action> for ListPage {
     fn new(state: &InboxState, action_tx: UnboundedSender<Action>) -> Self
     where
         Self: Sized,
     {
         Self {
             action_tx: action_tx.clone(),
             notifications: Notifications::new(state, action_tx.clone()),
             shortcuts: Shortcuts::new(state, action_tx.clone()),
         }
         .move_with_state(state)
     }
     fn move_with_state(self, state: &InboxState) -> Self
     where
         Self: Sized,
     {
         ListPage {
             notifications: self.notifications.move_with_state(state),
             shortcuts: self.shortcuts.move_with_state(state),
             ..self
         }
     }
     fn name(&self) -> &str {
         "list-page"
     }
     fn handle_key_event(&mut self, key: termion::event::Key) {
         match key {
             Key::Char('q') => {
                 let _ = self.action_tx.send(Action::Exit);
             }
             _ => {
                 <Notifications as Widget<InboxState, Action>>::handle_key_event(
                     &mut self.notifications,
                     key,
                 );
             }
         }
     }
 }
 impl Render<()> for ListPage {
     fn render<B: Backend>(&mut self, frame: &mut ratatui::Frame, _area: Rect, _props: ()) {
         let area = frame.size();
         let layout = tui::flux::ui::layout::default_page(area, 0u16, 1u16);
         self.notifications.render::<B>(frame, layout.component, ());
         self.shortcuts.render::<B>(
             frame,
             layout.shortcuts,
             ShortcutsProps {
                 shortcuts: vec![Shortcut::new("enter", "select"), Shortcut::new("q", "quit")],
                 divider: '∙',
             },
         );
     }
 }
 struct NotificationsProps {
     notifications: Vec<NotificationItem>,
 }
 impl From<&InboxState> for NotificationsProps {
     fn from(state: &InboxState) -> Self {
         Self {
             notifications: state.notifications.clone(),
         }
     }
 }
 struct Notifications {
     /// Sending actions to the state store
     action_tx: UnboundedSender<Action>,
     /// State Mapped RoomList Props
     props: NotificationsProps,
     /// Notification table
     table: Table<Action>,
 }
 impl Widget<InboxState, Action> for Notifications {
     fn new(state: &InboxState, action_tx: UnboundedSender<Action>) -> Self {
         Self {
             action_tx: action_tx.clone(),
             props: NotificationsProps::from(state),
             table: Table::new(state, action_tx.clone()),
         }
     }
     fn move_with_state(self, state: &InboxState) -> Self
     where
         Self: Sized,
     {
         Self {
             props: NotificationsProps::from(state),
             table: self.table.move_with_state(state),
             ..self
         }
     }
     fn name(&self) -> &str {
         "notification-list"
     }
     fn handle_key_event(&mut self, key: Key) {
         match key {
             Key::Up => {
                 self.table.prev();
                 let selected = self
                     .table
                     .selected()
                     .and_then(|selected| self.props.notifications.get(selected));
                 // TODO: propagate error
                 if let Some(notif) = selected {
                     let _ = self.action_tx.send(Action::Select(notif.id));
                 }
             }
             Key::Down => {
                 self.table.next(self.props.notifications.len());
                 let selected = self
                     .table
                     .selected()
                     .and_then(|selected| self.props.notifications.get(selected));
                 // TODO: propagate error
                 if let Some(notif) = selected {
                     let _ = self.action_tx.send(Action::Select(notif.id));
                 }
             }
             _ => {}
         }
     }
 }
 impl Render<()> for Notifications {
     fn render<B: Backend>(&mut self, frame: &mut ratatui::Frame, area: Rect, _props: ()) {
         let header: [Cell; 7] = [
             String::from("").into(),
             String::from(" ● ").into(),
             String::from("Type").into(),
             String::from("Summary").into(),
             String::from("ID").into(),
             String::from("Status").into(),
             String::from("Updated").into(),
         ];
         let widths = [
             Constraint::Length(5),
             Constraint::Length(3),
             Constraint::Length(6),
             Constraint::Fill(1),
             Constraint::Length(15),
             Constraint::Length(10),
             Constraint::Length(18),
         ];
         let progress = {
             let step = self
                 .table
                 .selected()
                 .map(|selected| selected.saturating_add(1).to_string())
                 .unwrap_or("-".to_string());
             let length = self.props.notifications.len().to_string();
             span::badge(format!("{}/{}", step, length))
         };
         let footer = FooterProps {
             cells: [
                 span::badge("/".to_string()),
                 String::from("").into(),
                 String::from("").into(),
                 progress.clone(),
             ]
             .to_vec(),
             widths: [
                 Constraint::Length(3),
                 Constraint::Fill(1),
                 Constraint::Fill(1),
                 Constraint::Length(progress.width() as u16),
             ]
             .to_vec(),
         };
         self.table.render::<B>(
             frame,
             area,
             TableProps {
                 items: self.props.notifications.to_vec(),
                 focus: false,
                 widths,
                 header,
                 footer: Some(footer),
             },
         );
     }
 }

added bin/commands/inbox/realm.rs

@@ -0,0 +1,2 @@

+	`#[path = "realm/select.rs"]`
+	`pub mod select;`

added bin/commands/inbox/realm/select.rs

@@ -0,0 +1,224 @@

 #[path = "select/event.rs"]
 mod event;
 #[path = "select/page.rs"]
 mod page;
 #[path = "select/ui.rs"]
 mod ui;
 use std::fmt::Display;
 use std::hash::Hash;
 use anyhow::Result;
 use serde::{Serialize, Serializer};
 use tuirealm::application::PollStrategy;
 use tuirealm::{Application, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::common::cob::inbox::{Filter, SortBy};
 use tui::common::context::Context;
 use tui::realm::ui::subscription;
 use tui::realm::ui::theme::Theme;
 use tui::realm::{PageStack, Tui};
 use tui::{Exit, SelectionExit};
 use page::ListView;
 use super::super::common::Mode;
 /// Wrapper around radicle's `PatchId` that serializes
 /// to a human-readable string.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PatchId(radicle::cob::patch::PatchId);
 impl From<radicle::cob::patch::PatchId> for PatchId {
     fn from(value: radicle::cob::patch::PatchId) -> Self {
         PatchId(value)
     }
 }
 impl Display for PatchId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.0)
     }
 }
 impl Serialize for PatchId {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         serializer.serialize_str(&format!("{}", *self.0))
     }
 }
 /// The selected issue operation returned by the operation
 /// selection widget.
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
 pub enum InboxOperation {
     Show,
     Clear,
 }
 impl Display for InboxOperation {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             InboxOperation::Show => {
                 write!(f, "show")
             }
             InboxOperation::Clear => {
                 write!(f, "clear")
             }
         }
     }
 }
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum ListCid {
     NotificationBrowser,
     Context,
     Shortcuts,
 }
 /// All component ids known to this application.
 #[derive(Debug, Default, Eq, PartialEq, Clone, Hash)]
 pub enum Cid {
     List(ListCid),
     #[default]
     GlobalListener,
 }
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum Message {
     #[default]
     Tick,
     Quit(Option<SelectionExit>),
     Batch(Vec<Message>),
 }
 pub struct App {
     context: Context,
     pages: PageStack<Cid, Message>,
     theme: Theme,
     mode: Mode,
     filter: Filter,
     sort_by: SortBy,
     quit: bool,
     output: Option<SelectionExit>,
 }
 /// Creates a new application using a tui-realm-application, mounts all
 /// components and sets focus to a default one.
 #[allow(dead_code)]
 impl App {
     pub fn new(context: Context, mode: Mode, filter: Filter, sort_by: SortBy) -> Self {
         Self {
             context,
             pages: PageStack::default(),
             theme: Theme::default(),
             mode,
             filter,
             sort_by,
             quit: false,
             output: None,
         }
     }
     fn view_list(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
     ) -> Result<()> {
         let home = Box::new(ListView::new(
             self.mode.clone(),
             self.filter.clone(),
             self.sort_by,
         ));
         self.pages.push(home, app, &self.context, theme)?;
         Ok(())
     }
     fn process(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         message: Message,
     ) -> Result<Option<Message>> {
         let theme = Theme::default();
         match message {
             Message::Batch(messages) => {
                 let mut results = vec![];
                 for message in messages {
                     if let Some(result) = self.process(app, message)? {
                         results.push(result);
                     }
                 }
                 match results.len() {
 => Ok(None),
 => Ok(Some(results[0].to_owned())),
                     _ => Ok(Some(Message::Batch(results))),
                 }
             }
             Message::Quit(output) => {
                 self.quit = true;
                 self.output = output;
                 Ok(None)
             }
             _ => self
                 .pages
                 .peek_mut()?
                 .update(app, &self.context, &theme, message),
         }
     }
 }
 impl Tui<Cid, Message, SelectionExit> for App {
     fn init(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         self.view_list(app, &self.theme.clone())?;
         // Add global key listener and subscribe to key events
         let global = tui::realm::ui::global_listener().to_boxed();
         app.mount(
             Cid::GlobalListener,
             global,
             vec![Sub::new(
                 subscription::quit_clause(tuirealm::event::Key::Char('q')),
                 SubClause::Always,
             )],
         )?;
         Ok(())
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         if let Ok(page) = self.pages.peek_mut() {
             page.view(app, frame);
         }
     }
     fn update(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<bool> {
         match app.tick(PollStrategy::Once) {
             Ok(messages) if !messages.is_empty() => {
                 for message in messages {
                     let mut msg = Some(message);
                     while msg.is_some() {
                         msg = self.process(app, msg.unwrap())?;
                     }
                 }
                 Ok(true)
             }
             _ => Ok(false),
         }
     }
     fn exit(&self) -> Option<Exit<SelectionExit>> {
         if self.quit {
             return Some(Exit {
                 value: self.output.clone(),
             });
         }
         None
     }
 }

added bin/commands/inbox/realm/select/event.rs

@@ -0,0 +1,161 @@

 use radicle::node::notifications::NotificationId;
 use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection};
 use tuirealm::event::{Event, Key, KeyEvent};
 use tuirealm::{MockComponent, NoUserEvent};
 use radicle_tui as tui;
 use tui::realm::ui::state::ItemState;
 use tui::realm::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer};
 use tui::realm::ui::widget::context::{ContextBar, Shortcuts};
 use tui::realm::ui::widget::list::PropertyList;
 use tui::realm::ui::widget::Widget;
 use tui::{Id, SelectionExit};
 use super::ui::{IdSelect, OperationSelect};
 use super::{InboxOperation, Message};
 /// Since the framework does not know the type of messages that are being
 /// passed around in the app, the following handlers need to be implemented for
 /// each component used.
 ///
 /// TODO: should handle `Event::WindowResize`, which is not emitted by `termion`.
 impl tuirealm::Component<Message, NoUserEvent> for Widget<GlobalListener> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent {
                 code: Key::Char('q'),
                 ..
             }) => Some(Message::Quit(None)),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<IdSelect> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         let mut submit = || -> Option<NotificationId> {
             match self.perform(Cmd::Submit) {
                 CmdResult::Submit(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(item.id().to_owned())
                 }
                 _ => None,
             }
         };
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => submit().map(|id| {
                 let output = SelectionExit::default().with_id(Id::Notification(id));
                 Message::Quit(Some(output))
             }),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<OperationSelect> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         let mut submit = || -> Option<NotificationId> {
             match self.perform(Cmd::Submit) {
                 CmdResult::Submit(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(item.id().to_owned())
                 }
                 _ => None,
             }
         };
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(InboxOperation::Show.to_string())
                     .with_id(Id::Notification(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('c'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(InboxOperation::Clear.to_string())
                     .with_id(Id::Notification(id));
                 Message::Quit(Some(exit))
             }),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<AppHeader> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<LabeledContainer> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<PropertyList> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ContextBar> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Shortcuts> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }

added bin/commands/inbox/realm/select/page.rs

@@ -0,0 +1,168 @@

 use std::collections::HashMap;
 use anyhow::Result;
 use tuirealm::{AttrValue, Attribute, Frame, NoUserEvent};
 use radicle_tui as tui;
 use tui::common::cob::inbox::{Filter, SortBy};
 use tui::common::context::Context;
 use tui::realm::ui::layout;
 use tui::realm::ui::state::ItemState;
 use tui::realm::ui::theme::Theme;
 use tui::realm::ui::widget::context::{Progress, Shortcuts};
 use tui::realm::ui::widget::Widget;
 use tui::realm::ViewPage;
 use super::{ui, Application, Cid, ListCid, Message, Mode};
 ///
 /// Home
 ///
 pub struct ListView {
     active_component: ListCid,
     mode: Mode,
     filter: Filter,
     sort_by: SortBy,
     shortcuts: HashMap<ListCid, Widget<Shortcuts>>,
 }
 impl ListView {
     pub fn new(mode: Mode, filter: Filter, sort_by: SortBy) -> Self {
         Self {
             active_component: ListCid::NotificationBrowser,
             mode,
             filter,
             sort_by,
             shortcuts: HashMap::default(),
         }
     }
     fn update_context(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let state = app.state(&Cid::List(ListCid::NotificationBrowser))?;
         let progress = match ItemState::try_from(state) {
             Ok(state) => Progress::Step(
                 state
                     .selected()
                     .map(|s| s.saturating_add(1))
                     .unwrap_or_default(),
                 state.len(),
             ),
             Err(_) => Progress::None,
         };
         let context = ui::browse_context(context, theme, self.filter.clone(), progress);
         app.remount(Cid::List(ListCid::Context), context.to_boxed(), vec![])?;
         Ok(())
     }
     fn update_shortcuts(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: ListCid,
     ) -> Result<()> {
         if let Some(shortcuts) = self.shortcuts.get(&cid) {
             app.remount(
                 Cid::List(ListCid::Shortcuts),
                 shortcuts.clone().to_boxed(),
                 vec![],
             )?;
         }
         Ok(())
     }
 }
 impl ViewPage<Cid, Message> for ListView {
     fn mount(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let browser = ui::operation_select(theme, context, self.filter.clone(), self.sort_by, None)
             .to_boxed();
         self.shortcuts = browser.as_ref().shortcuts();
         match self.mode {
             Mode::Id => {
                 let notif_browser =
                     ui::id_select(theme, context, self.filter.clone(), self.sort_by, None)
                         .to_boxed();
                 self.shortcuts = notif_browser.as_ref().shortcuts();
                 app.remount(Cid::List(ListCid::NotificationBrowser), browser, vec![])?;
             }
             Mode::Operation => {
                 let notif_browser =
                     ui::operation_select(theme, context, self.filter.clone(), self.sort_by, None)
                         .to_boxed();
                 self.shortcuts = notif_browser.as_ref().shortcuts();
                 app.remount(Cid::List(ListCid::NotificationBrowser), browser, vec![])?;
             }
         };
         app.active(&Cid::List(self.active_component.clone()))?;
         self.update_shortcuts(app, self.active_component.clone())?;
         self.update_context(app, context, theme)?;
         Ok(())
     }
     fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.umount(&Cid::List(ListCid::NotificationBrowser))?;
         app.umount(&Cid::List(ListCid::Context))?;
         app.umount(&Cid::List(ListCid::Shortcuts))?;
         Ok(())
     }
     fn update(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         _message: Message,
     ) -> Result<Option<Message>> {
         self.update_context(app, context, theme)?;
         Ok(None)
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         let area = frame.size();
         let context_h = app
             .query(&Cid::List(ListCid::Context), Attribute::Height)
             .unwrap_or_default()
             .unwrap_or(AttrValue::Size(0))
             .unwrap_size();
         let shortcuts_h = 1u16;
         let layout = layout::default_page(area, context_h, shortcuts_h);
         app.view(
             &Cid::List(self.active_component.clone()),
             frame,
             layout.component,
         );
         app.view(&Cid::List(ListCid::Context), frame, layout.context);
         app.view(&Cid::List(ListCid::Shortcuts), frame, layout.shortcuts);
     }
     fn subscribe(&self, _app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         Ok(())
     }
     fn unsubscribe(&self, _app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         Ok(())
     }
 }

added bin/commands/inbox/realm/select/ui.rs

@@ -0,0 +1,267 @@

 use std::collections::HashMap;
 use radicle::node::notifications::Notification;
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State};
 use radicle_tui as tui;
 use tui::common::cob::inbox::{Filter, SortBy};
 use tui::common::context::Context;
 use tui::realm::ui::cob::NotificationItem;
 use tui::realm::ui::theme::{style, Theme};
 use tui::realm::ui::widget::context::{ContextBar, Progress, Shortcuts};
 use tui::realm::ui::widget::label::{self};
 use tui::realm::ui::widget::list::{ColumnWidth, Table};
 use tui::realm::ui::widget::{Widget, WidgetComponent};
 use super::ListCid;
 pub struct NotificationBrowser {
     items: Vec<NotificationItem>,
     table: Widget<Table<NotificationItem, 7>>,
 }
 impl NotificationBrowser {
     pub fn new(
         theme: &Theme,
         context: &Context,
         sort_by: SortBy,
         selected: Option<Notification>,
     ) -> Self {
         let header = [
             label::header(""),
             label::header(" ● "),
             label::header("Type"),
             label::header("Summary"),
             label::header("ID"),
             label::header("Status"),
             label::header("Updated"),
         ];
         let widths = [
             ColumnWidth::Fixed(5),
             ColumnWidth::Fixed(3),
             ColumnWidth::Fixed(6),
             ColumnWidth::Grow,
             ColumnWidth::Fixed(15),
             ColumnWidth::Fixed(10),
             ColumnWidth::Fixed(18),
         ];
         let mut items = vec![];
         for notification in context.notifications() {
             if let Ok(item) =
                 NotificationItem::try_from((context.repository(), notification.clone()))
             {
                 items.push(item);
             }
         }
         match sort_by.field {
             "timestamp" => items.sort_by(|a, b| b.timestamp().cmp(a.timestamp())),
             "id" => items.sort_by(|a, b| b.id().cmp(a.id())),
             _ => {}
         }
         if sort_by.reverse {
             items.reverse();
         }
         let selected = match selected {
             Some(notif) => {
                 Some(NotificationItem::try_from((context.repository(), notif.clone())).unwrap())
             }
             _ => items.first().cloned(),
         };
         let table = Widget::new(Table::new(&items, selected, header, widths, theme.clone()));
         Self { items, table }
     }
     pub fn items(&self) -> &Vec<NotificationItem> {
         &self.items
     }
 }
 impl WidgetComponent for NotificationBrowser {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.table.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.table.view(frame, area);
     }
     fn state(&self) -> State {
         self.table.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.table.perform(cmd)
     }
 }
 pub struct IdSelect {
     theme: Theme,
     browser: Widget<NotificationBrowser>,
 }
 impl IdSelect {
     pub fn new(theme: Theme, browser: Widget<NotificationBrowser>) -> Self {
         Self { theme, browser }
     }
     pub fn items(&self) -> &Vec<NotificationItem> {
         self.browser.items()
     }
     pub fn shortcuts(&self) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::NotificationBrowser,
             tui::realm::ui::shortcuts(
                 &self.theme,
                 vec![
                     tui::realm::ui::shortcut(&self.theme, "enter", "select"),
                     tui::realm::ui::shortcut(&self.theme, "q", "quit"),
                 ],
             ),
         )]
         .iter()
         .cloned()
         .collect()
     }
 }
 impl WidgetComponent for IdSelect {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.browser.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.browser.view(frame, area);
     }
     fn state(&self) -> State {
         self.browser.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.browser.perform(cmd)
     }
 }
 pub struct OperationSelect {
     theme: Theme,
     browser: Widget<NotificationBrowser>,
 }
 impl OperationSelect {
     pub fn new(theme: Theme, browser: Widget<NotificationBrowser>) -> Self {
         Self { theme, browser }
     }
     pub fn items(&self) -> &Vec<NotificationItem> {
         self.browser.items()
     }
     pub fn shortcuts(&self) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::NotificationBrowser,
             tui::realm::ui::shortcuts(
                 &self.theme,
                 vec![
                     tui::realm::ui::shortcut(&self.theme, "enter", "show"),
                     tui::realm::ui::shortcut(&self.theme, "c", "clear"),
                     tui::realm::ui::shortcut(&self.theme, "q", "quit"),
                 ],
             ),
         )]
         .iter()
         .cloned()
         .collect()
     }
 }
 impl WidgetComponent for OperationSelect {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.browser.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.browser.view(frame, area);
     }
     fn state(&self) -> State {
         self.browser.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.browser.perform(cmd)
     }
 }
 pub fn id_select(
     theme: &Theme,
     context: &Context,
     _filter: Filter,
     sort_by: SortBy,
     selected: Option<Notification>,
 ) -> Widget<IdSelect> {
     let browser = Widget::new(NotificationBrowser::new(theme, context, sort_by, selected));
     Widget::new(IdSelect::new(theme.clone(), browser))
 }
 pub fn operation_select(
     theme: &Theme,
     context: &Context,
     _filter: Filter,
     sort_by: SortBy,
     selected: Option<Notification>,
 ) -> Widget<OperationSelect> {
     let browser = Widget::new(NotificationBrowser::new(theme, context, sort_by, selected));
     Widget::new(OperationSelect::new(theme.clone(), browser))
 }
 pub fn browse_context(
     _context: &Context,
     _theme: &Theme,
     _filter: Filter,
     progress: Progress,
 ) -> Widget<ContextBar> {
     let context = label::reversable("/").style(style::magenta_reversed());
     let filter = label::default("").style(style::magenta_dim());
     let progress = label::reversable(&progress.to_string()).style(style::magenta_reversed());
     let spacer = label::default("");
     let _divider = label::default(" | ");
     let context_bar = ContextBar::new(
         label::group(&[context]),
         label::group(&[filter]),
         label::group(&[spacer.clone()]),
         label::group(&[
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
         ]),
         label::group(&[progress]),
     );
     Widget::new(context_bar).height(1)
 }

deleted bin/commands/inbox/select.rs

@@ -1,233 +0,0 @@

 #[path = "select/event.rs"]
 mod event;
 #[path = "select/page.rs"]
 mod page;
 #[path = "select/ui.rs"]
 mod ui;
 use std::fmt::Display;
 use std::hash::Hash;
 use anyhow::Result;
 use serde::{Serialize, Serializer};
 use tuirealm::application::PollStrategy;
 use tuirealm::event::Key;
 use tuirealm::{Application, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::cob::inbox::{Filter, SortBy};
 use tui::context::Context;
 use tui::ui::subscription;
 use tui::ui::theme::Theme;
 use tui::{Exit, PageStack, SelectionExit, Tui};
 use page::ListView;
 /// Wrapper around radicle's `PatchId` that serializes
 /// to a human-readable string.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PatchId(radicle::cob::patch::PatchId);
 impl From<radicle::cob::patch::PatchId> for PatchId {
     fn from(value: radicle::cob::patch::PatchId) -> Self {
         PatchId(value)
     }
 }
 impl Display for PatchId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.0)
     }
 }
 impl Serialize for PatchId {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         serializer.serialize_str(&format!("{}", *self.0))
     }
 }
 /// The application's subject. It tells the application
 /// which widgets to render and which output to produce.
 ///
 /// Depends on CLI arguments given by the user.
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum Mode {
     #[default]
     Operation,
     #[allow(dead_code)]
     Id,
 }
 /// The selected issue operation returned by the operation
 /// selection widget.
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
 pub enum InboxOperation {
     Show,
     Clear,
 }
 impl Display for InboxOperation {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             InboxOperation::Show => {
                 write!(f, "show")
             }
             InboxOperation::Clear => {
                 write!(f, "clear")
             }
         }
     }
 }
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum ListCid {
     NotificationBrowser,
     Context,
     Shortcuts,
 }
 /// All component ids known to this application.
 #[derive(Debug, Default, Eq, PartialEq, Clone, Hash)]
 pub enum Cid {
     List(ListCid),
     #[default]
     GlobalListener,
 }
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum Message {
     #[default]
     Tick,
     Quit(Option<SelectionExit>),
     Batch(Vec<Message>),
 }
 pub struct App {
     context: Context,
     pages: PageStack<Cid, Message>,
     theme: Theme,
     mode: Mode,
     filter: Filter,
     sort_by: SortBy,
     output: Option<SelectionExit>,
     quit: bool,
 }
 /// Creates a new application using a tui-realm-application, mounts all
 /// components and sets focus to a default one.
 impl App {
     pub fn new(context: Context, mode: Mode, filter: Filter, sort_by: SortBy) -> Self {
         Self {
             context,
             pages: PageStack::default(),
             theme: Theme::default(),
             mode,
             filter,
             sort_by,
             output: None,
             quit: false,
         }
     }
     fn view_list(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
     ) -> Result<()> {
         let home = Box::new(ListView::new(
             self.mode.clone(),
             self.filter.clone(),
             self.sort_by,
         ));
         self.pages.push(home, app, &self.context, theme)?;
         Ok(())
     }
     fn process(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         message: Message,
     ) -> Result<Option<Message>> {
         let theme = Theme::default();
         match message {
             Message::Batch(messages) => {
                 let mut results = vec![];
                 for message in messages {
                     if let Some(result) = self.process(app, message)? {
                         results.push(result);
                     }
                 }
                 match results.len() {
 => Ok(None),
 => Ok(Some(results[0].to_owned())),
                     _ => Ok(Some(Message::Batch(results))),
                 }
             }
             Message::Quit(output) => {
                 self.quit = true;
                 self.output = output;
                 Ok(None)
             }
             _ => self
                 .pages
                 .peek_mut()?
                 .update(app, &self.context, &theme, message),
         }
     }
 }
 impl Tui<Cid, Message, SelectionExit> for App {
     fn init(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         self.view_list(app, &self.theme.clone())?;
         // Add global key listener and subscribe to key events
         let global = tui::ui::global_listener().to_boxed();
         app.mount(
             Cid::GlobalListener,
             global,
             vec![Sub::new(
                 subscription::quit_clause(Key::Char('q')),
                 SubClause::Always,
             )],
         )?;
         Ok(())
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         if let Ok(page) = self.pages.peek_mut() {
             page.view(app, frame);
         }
     }
     fn update(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<bool> {
         match app.tick(PollStrategy::Once) {
             Ok(messages) if !messages.is_empty() => {
                 for message in messages {
                     let mut msg = Some(message);
                     while msg.is_some() {
                         msg = self.process(app, msg.unwrap())?;
                     }
                 }
                 Ok(true)
             }
             _ => Ok(false),
         }
     }
     fn exit(&self) -> Option<Exit<SelectionExit>> {
         if self.quit {
             return Some(Exit {
                 value: self.output.clone(),
             });
         }
         None
     }
 }

modified bin/commands/inbox/select/event.rs

@@ -6,11 +6,11 @@ use tuirealm::{MockComponent, NoUserEvent};

 use radicle_tui as tui;
 use tui::ui::state::ItemState;
 use tui::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer};
 use tui::ui::widget::context::{ContextBar, Shortcuts};
 use tui::ui::widget::list::PropertyList;
 use tui::ui::widget::Widget;
 use tui::realm::ui::state::ItemState;
 use tui::realm::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer};
 use tui::realm::ui::widget::context::{ContextBar, Shortcuts};
 use tui::realm::ui::widget::list::PropertyList;
 use tui::realm::ui::widget::Widget;
 use tui::{Id, SelectionExit};
 use super::ui::{IdSelect, OperationSelect};

modified bin/commands/inbox/select/page.rs

@@ -6,14 +6,14 @@ use tuirealm::{AttrValue, Attribute, Frame, NoUserEvent};

 use radicle_tui as tui;
 use tui::cob::inbox::{Filter, SortBy};
 use tui::context::Context;
 use tui::ui::layout;
 use tui::ui::state::ItemState;
 use tui::ui::theme::Theme;
 use tui::ui::widget::context::{Progress, Shortcuts};
 use tui::ui::widget::Widget;
 use tui::ViewPage;
 use tui::common::cob::inbox::{Filter, SortBy};
 use tui::common::context::Context;
 use tui::realm::ui::layout;
 use tui::realm::ui::state::ItemState;
 use tui::realm::ui::theme::Theme;
 use tui::realm::ui::widget::context::{Progress, Shortcuts};
 use tui::realm::ui::widget::Widget;
 use tui::realm::ViewPage;
 use super::{ui, Application, Cid, ListCid, Message, Mode};

modified bin/commands/inbox/select/ui.rs

@@ -2,20 +2,20 @@ use std::collections::HashMap;

 use radicle::node::notifications::Notification;
 use tui::ui::cob::NotificationItem;
 use tui::ui::widget::list::{ColumnWidth, Table};
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State};
 use radicle_tui as tui;
 use tui::cob::inbox::{Filter, SortBy};
 use tui::context::Context;
 use tui::ui::theme::{style, Theme};
 use tui::ui::widget::context::{ContextBar, Progress, Shortcuts};
 use tui::ui::widget::label::{self};
 use tui::ui::widget::{Widget, WidgetComponent};
 use tui::common::cob::inbox::{Filter, SortBy};
 use tui::common::context::Context;
 use tui::realm::ui::cob::NotificationItem;
 use tui::realm::ui::theme::{style, Theme};
 use tui::realm::ui::widget::context::{ContextBar, Progress, Shortcuts};
 use tui::realm::ui::widget::label::{self};
 use tui::realm::ui::widget::list::{ColumnWidth, Table};
 use tui::realm::ui::widget::{Widget, WidgetComponent};
 use super::ListCid;

@@ -121,11 +121,11 @@ impl IdSelect {

     pub fn shortcuts(&self) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::NotificationBrowser,
             tui::ui::shortcuts(
             tui::realm::ui::shortcuts(
                 &self.theme,
                 vec![
                     tui::ui::shortcut(&self.theme, "enter", "select"),
                     tui::ui::shortcut(&self.theme, "q", "quit"),
                     tui::realm::ui::shortcut(&self.theme, "enter", "select"),
                     tui::realm::ui::shortcut(&self.theme, "q", "quit"),
                 ],
             ),
         )]

@@ -171,12 +171,12 @@ impl OperationSelect {

     pub fn shortcuts(&self) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::NotificationBrowser,
             tui::ui::shortcuts(
             tui::realm::ui::shortcuts(
                 &self.theme,
                 vec![
                     tui::ui::shortcut(&self.theme, "enter", "show"),
                     tui::ui::shortcut(&self.theme, "c", "clear"),
                     tui::ui::shortcut(&self.theme, "q", "quit"),
                     tui::realm::ui::shortcut(&self.theme, "enter", "show"),
                     tui::realm::ui::shortcut(&self.theme, "c", "clear"),
                     tui::realm::ui::shortcut(&self.theme, "q", "quit"),
                 ],
             ),
         )]

modified bin/commands/issue.rs

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

 #[cfg(feature = "realm")]
 #[path = "issue/realm.rs"]
 mod realm;
 #[path = "issue/common.rs"]
 mod common;
 #[path = "issue/select.rs"]
 mod select;
 #[path = "issue/suite.rs"]
 mod suite;
 use std::ffi::OsString;

@@ -11,13 +11,11 @@ use anyhow::anyhow;

 use radicle_tui as tui;
 use tui::cob::issue::{self, State};
 use tui::{context, log, Window};
 use tui::common::cob::issue::{self, State};
 use crate::terminal;
 use crate::terminal::args::{Args, Error, Help};
 pub const FPS: u64 = 60;
 pub const HELP: Help = Help {
     name: "issue",
     description: "Terminal interfaces for issues",

@@ -55,7 +53,7 @@ pub enum OperationName {

 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct SelectOptions {
     mode: select::Mode,
     mode: common::Mode,
     filter: issue::Filter,
 }

@@ -79,8 +77,8 @@ impl Args for Options {

                     let val = val.to_str().unwrap_or_default();
                     select_opts.mode = match val {
                         "operation" => select::Mode::Operation,
                         "id" => select::Mode::Id,
                         "operation" => common::Mode::Operation,
                         "id" => common::Mode::Id,
                         unknown => anyhow::bail!("unknown mode '{}'", unknown),
                     };
                 }

@@ -120,7 +118,13 @@ impl Args for Options {

     }
 }
 #[cfg(feature = "realm")]
 pub fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()> {
     use tui::common::context;
     use tui::common::log;
     use tui::realm::Window;
     pub const FPS: u64 = 60;
     let (_, id) = radicle::rad::cwd()
         .map_err(|_| anyhow!("this command must be run in the context of a project"))?;

@@ -131,7 +135,7 @@ pub fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()>

             log::enable(context.profile(), "issue", "select")?;
             let mut app = select::App::new(context, opts.mode.clone(), opts.filter.clone());
             let mut app = realm::select::App::new(context, opts.mode.clone(), opts.filter.clone());
             let output = Window::default().run(&mut app, 1000 / FPS)?;
             let output = output

@@ -144,3 +148,12 @@ pub fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()>

     Ok(())
 }
 #[cfg(feature = "flux")]
 pub fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()> {
     match options.op {
         Operation::Select { opts: _ } => {
             anyhow::bail!("operation not yet implemented with flux")
         }
     }
 }

modified bin/commands/issue/common.rs

@@ -1,2 +1,9 @@

 #[path = "common/ui.rs"]
 pub mod ui;
 /// The application's mode. It tells the application
 /// which widgets to render and which output to produce.
 /// Depends on CLI arguments given by the user.
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum Mode {
     #[default]
     Operation,
     Id,
 }

deleted bin/commands/issue/common/ui.rs

@@ -1,163 +0,0 @@

 use radicle::issue::{Issue, IssueId};
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State};
 use radicle_tui as tui;
 use tui::cob::issue::Filter;
 use tui::context::Context;
 use tui::ui::cob::IssueItem;
 use tui::ui::theme::{style, Theme};
 use tui::ui::widget::context::{ContextBar, Progress};
 use tui::ui::widget::{Widget, WidgetComponent};
 use tui::ui::widget::label::{self};
 use tui::ui::widget::list::{ColumnWidth, Table};
 pub struct IssueBrowser {
     items: Vec<IssueItem>,
     table: Widget<Table<IssueItem, 7>>,
 }
 impl IssueBrowser {
     pub fn new(
         theme: &Theme,
         context: &Context,
         filter: Filter,
         selected: Option<(IssueId, Issue)>,
     ) -> Self {
         let header = [
             label::header(" ● "),
             label::header("ID"),
             label::header("Title"),
             label::header("Author"),
             label::header("Tags"),
             label::header("Assignees"),
             label::header("Opened"),
         ];
         let widths = [
             ColumnWidth::Fixed(3),
             ColumnWidth::Fixed(7),
             ColumnWidth::Grow,
             ColumnWidth::Fixed(21),
             ColumnWidth::Fixed(25),
             ColumnWidth::Fixed(21),
             ColumnWidth::Fixed(18),
         ];
         let repo = context.repository();
         let issues = context
             .issues()
             .as_ref()
             .unwrap()
             .iter()
             .filter(|(_, issue)| filter.matches(context.profile(), issue));
         let mut items = vec![];
         for (id, issue) in issues {
             if let Ok(item) = IssueItem::try_from((context.profile(), repo, *id, issue.clone())) {
                 items.push(item);
             }
         }
         items.sort_by(|a, b| b.timestamp().cmp(a.timestamp()));
         items.sort_by(|a, b| b.state().cmp(a.state()));
         let selected = match selected {
             Some((id, issue)) => Some(IssueItem::from((context.profile(), repo, id, issue))),
             _ => items.first().cloned(),
         };
         let table = Widget::new(Table::new(&items, selected, header, widths, theme.clone()));
         Self { items, table }
     }
     pub fn items(&self) -> &Vec<IssueItem> {
         &self.items
     }
 }
 impl WidgetComponent for IssueBrowser {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.table.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.table.view(frame, area);
     }
     fn state(&self) -> State {
         self.table.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.table.perform(cmd)
     }
 }
 pub fn browse_context(
     context: &Context,
     _theme: &Theme,
     filter: Filter,
     progress: Progress,
 ) -> Widget<ContextBar> {
     use radicle::issue::State;
     let mut open = 0;
     let mut closed = 0;
     let issues = context
         .issues()
         .as_ref()
         .unwrap()
         .iter()
         .filter(|(_, issue)| filter.matches(context.profile(), issue));
     for (_, issue) in issues {
         match issue.state() {
             State::Open => open += 1,
             State::Closed { reason: _ } => closed += 1,
         }
     }
     let context = label::reversable("/").style(style::magenta_reversed());
     let filter = label::default(&filter.to_string()).style(style::magenta_dim());
     let open_n = label::default(&format!("{open}")).style(style::green());
     let open = label::default(" Open");
     let closed_n = label::default(&format!("{closed}")).style(style::cyan());
     let closed = label::default(" Closed ");
     let progress = label::reversable(&progress.to_string()).style(style::magenta_reversed());
     let spacer = label::default("");
     let divider = label::default(" | ");
     let context_bar = ContextBar::new(
         label::group(&[context]),
         label::group(&[filter]),
         label::group(&[spacer.clone()]),
         label::group(&[
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
             spacer,
             open_n,
             open,
             divider,
             closed_n,
             closed,
         ]),
         label::group(&[progress]),
     );
     Widget::new(context_bar).height(1)
 }

added bin/commands/issue/realm.rs

@@ -0,0 +1,6 @@

 #[path = "realm/common.rs"]
 pub mod common;
 #[path = "realm/select.rs"]
 pub mod select;
 #[path = "realm/suite.rs"]
 pub mod suite;

added bin/commands/issue/realm/common.rs

@@ -0,0 +1,2 @@

+	`#[path = "common/ui.rs"]`
+	`pub mod ui;`

added bin/commands/issue/realm/common/ui.rs

@@ -0,0 +1,162 @@

 use radicle::issue::{Issue, IssueId};
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State};
 use radicle_tui as tui;
 use tui::common::cob::issue::Filter;
 use tui::common::context::Context;
 use tui::realm::ui::cob::IssueItem;
 use tui::realm::ui::theme::{style, Theme};
 use tui::realm::ui::widget::context::{ContextBar, Progress};
 use tui::realm::ui::widget::label::{self};
 use tui::realm::ui::widget::list::{ColumnWidth, Table};
 use tui::realm::ui::widget::{Widget, WidgetComponent};
 pub struct IssueBrowser {
     items: Vec<IssueItem>,
     table: Widget<Table<IssueItem, 7>>,
 }
 impl IssueBrowser {
     pub fn new(
         theme: &Theme,
         context: &Context,
         filter: Filter,
         selected: Option<(IssueId, Issue)>,
     ) -> Self {
         let header = [
             label::header(" ● "),
             label::header("ID"),
             label::header("Title"),
             label::header("Author"),
             label::header("Tags"),
             label::header("Assignees"),
             label::header("Opened"),
         ];
         let widths = [
             ColumnWidth::Fixed(3),
             ColumnWidth::Fixed(7),
             ColumnWidth::Grow,
             ColumnWidth::Fixed(21),
             ColumnWidth::Fixed(25),
             ColumnWidth::Fixed(21),
             ColumnWidth::Fixed(18),
         ];
         let repo = context.repository();
         let issues = context
             .issues()
             .as_ref()
             .unwrap()
             .iter()
             .filter(|(_, issue)| filter.matches(context.profile(), issue));
         let mut items = vec![];
         for (id, issue) in issues {
             if let Ok(item) = IssueItem::try_from((context.profile(), repo, *id, issue.clone())) {
                 items.push(item);
             }
         }
         items.sort_by(|a, b| b.timestamp().cmp(a.timestamp()));
         items.sort_by(|a, b| b.state().cmp(a.state()));
         let selected = match selected {
             Some((id, issue)) => Some(IssueItem::from((context.profile(), repo, id, issue))),
             _ => items.first().cloned(),
         };
         let table = Widget::new(Table::new(&items, selected, header, widths, theme.clone()));
         Self { items, table }
     }
     pub fn items(&self) -> &Vec<IssueItem> {
         &self.items
     }
 }
 impl WidgetComponent for IssueBrowser {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.table.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.table.view(frame, area);
     }
     fn state(&self) -> State {
         self.table.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.table.perform(cmd)
     }
 }
 pub fn browse_context(
     context: &Context,
     _theme: &Theme,
     filter: Filter,
     progress: Progress,
 ) -> Widget<ContextBar> {
     use radicle::issue::State;
     let mut open = 0;
     let mut closed = 0;
     let issues = context
         .issues()
         .as_ref()
         .unwrap()
         .iter()
         .filter(|(_, issue)| filter.matches(context.profile(), issue));
     for (_, issue) in issues {
         match issue.state() {
             State::Open => open += 1,
             State::Closed { reason: _ } => closed += 1,
         }
     }
     let context = label::reversable("/").style(style::magenta_reversed());
     let filter = label::default(&filter.to_string()).style(style::magenta_dim());
     let open_n = label::default(&format!("{open}")).style(style::green());
     let open = label::default(" Open");
     let closed_n = label::default(&format!("{closed}")).style(style::cyan());
     let closed = label::default(" Closed ");
     let progress = label::reversable(&progress.to_string()).style(style::magenta_reversed());
     let spacer = label::default("");
     let divider = label::default(" | ");
     let context_bar = ContextBar::new(
         label::group(&[context]),
         label::group(&[filter]),
         label::group(&[spacer.clone()]),
         label::group(&[
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
             spacer.clone(),
             spacer,
             open_n,
             open,
             divider,
             closed_n,
             closed,
         ]),
         label::group(&[progress]),
     );
     Widget::new(context_bar).height(1)
 }

added bin/commands/issue/realm/select.rs

@@ -0,0 +1,227 @@

 #[path = "select/event.rs"]
 mod event;
 #[path = "select/page.rs"]
 mod page;
 #[path = "select/ui.rs"]
 mod ui;
 use std::fmt::Display;
 use std::hash::Hash;
 use anyhow::Result;
 use serde::{Serialize, Serializer};
 use tuirealm::application::PollStrategy;
 use tuirealm::event::Key;
 use tuirealm::{Application, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::common::cob::issue::Filter;
 use tui::common::context::Context;
 use tui::realm::ui::subscription;
 use tui::realm::ui::theme::Theme;
 use tui::realm::{PageStack, Tui};
 use tui::{Exit, SelectionExit};
 use page::ListView;
 use super::super::common::Mode;
 /// Wrapper around radicle's `PatchId` that serializes
 /// to a human-readable string.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PatchId(radicle::cob::patch::PatchId);
 impl From<radicle::cob::patch::PatchId> for PatchId {
     fn from(value: radicle::cob::patch::PatchId) -> Self {
         PatchId(value)
     }
 }
 impl Display for PatchId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.0)
     }
 }
 impl Serialize for PatchId {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         serializer.serialize_str(&format!("{}", *self.0))
     }
 }
 /// The selected issue operation returned by the operation
 /// selection widget.
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
 pub enum IssueOperation {
     Show,
     Delete,
     Edit,
     Comment,
 }
 impl Display for IssueOperation {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             IssueOperation::Show => {
                 write!(f, "show")
             }
             IssueOperation::Delete => {
                 write!(f, "delete")
             }
             IssueOperation::Edit => {
                 write!(f, "edit")
             }
             IssueOperation::Comment => {
                 write!(f, "comment")
             }
         }
     }
 }
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum ListCid {
     Header,
     PatchBrowser,
     Context,
     Shortcuts,
 }
 /// All component ids known to this application.
 #[derive(Debug, Default, Eq, PartialEq, Clone, Hash)]
 pub enum Cid {
     List(ListCid),
     #[default]
     GlobalListener,
 }
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum Message {
     #[default]
     Tick,
     Quit(Option<SelectionExit>),
     Batch(Vec<Message>),
 }
 pub struct App {
     context: Context,
     pages: PageStack<Cid, Message>,
     theme: Theme,
     quit: bool,
     mode: Mode,
     filter: Filter,
     output: Option<SelectionExit>,
 }
 /// Creates a new application using a tui-realm-application, mounts all
 /// components and sets focus to a default one.
 impl App {
     pub fn new(context: Context, mode: Mode, filter: Filter) -> Self {
         Self {
             context,
             pages: PageStack::default(),
             theme: Theme::default(),
             quit: false,
             mode,
             filter,
             output: None,
         }
     }
     fn view_list(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
     ) -> Result<()> {
         let home = Box::new(ListView::new(self.mode.clone(), self.filter.clone()));
         self.pages.push(home, app, &self.context, theme)?;
         Ok(())
     }
     fn process(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         message: Message,
     ) -> Result<Option<Message>> {
         let theme = Theme::default();
         match message {
             Message::Batch(messages) => {
                 let mut results = vec![];
                 for message in messages {
                     if let Some(result) = self.process(app, message)? {
                         results.push(result);
                     }
                 }
                 match results.len() {
 => Ok(None),
 => Ok(Some(results[0].to_owned())),
                     _ => Ok(Some(Message::Batch(results))),
                 }
             }
             Message::Quit(output) => {
                 self.quit = true;
                 self.output = output;
                 Ok(None)
             }
             _ => self
                 .pages
                 .peek_mut()?
                 .update(app, &self.context, &theme, message),
         }
     }
 }
 impl Tui<Cid, Message, SelectionExit> for App {
     fn init(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         self.view_list(app, &self.theme.clone())?;
         // Add global key listener and subscribe to key events
         let global = tui::realm::ui::global_listener().to_boxed();
         app.mount(
             Cid::GlobalListener,
             global,
             vec![Sub::new(
                 subscription::quit_clause(Key::Char('q')),
                 SubClause::Always,
             )],
         )?;
         Ok(())
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         if let Ok(page) = self.pages.peek_mut() {
             page.view(app, frame);
         }
     }
     fn update(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<bool> {
         match app.tick(PollStrategy::Once) {
             Ok(messages) if !messages.is_empty() => {
                 for message in messages {
                     let mut msg = Some(message);
                     while msg.is_some() {
                         msg = self.process(app, msg.unwrap())?;
                     }
                 }
                 Ok(true)
             }
             _ => Ok(false),
         }
     }
     fn exit(&self) -> Option<Exit<SelectionExit>> {
         if self.quit {
             return Some(Exit {
                 value: self.output.clone(),
             });
         }
         None
     }
 }

added bin/commands/issue/realm/select/event.rs

@@ -0,0 +1,177 @@

 use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection};
 use tuirealm::event::{Event, Key, KeyEvent};
 use tuirealm::{MockComponent, NoUserEvent};
 use radicle_tui as tui;
 use tui::realm::ui::state::ItemState;
 use tui::realm::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer};
 use tui::realm::ui::widget::context::{ContextBar, Shortcuts};
 use tui::realm::ui::widget::list::PropertyList;
 use tui::realm::ui::widget::Widget;
 use tui::{Id, SelectionExit};
 use super::ui::{IdSelect, OperationSelect};
 use super::{IssueOperation, Message};
 /// Since the framework does not know the type of messages that are being
 /// passed around in the app, the following handlers need to be implemented for
 /// each component used.
 ///
 /// TODO: should handle `Event::WindowResize`, which is not emitted by `termion`.
 impl tuirealm::Component<Message, NoUserEvent> for Widget<GlobalListener> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent {
                 code: Key::Char('q'),
                 ..
             }) => Some(Message::Quit(None)),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<IdSelect> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         let mut submit = || -> Option<radicle::cob::patch::PatchId> {
             match self.perform(Cmd::Submit) {
                 CmdResult::Submit(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(item.id().to_owned())
                 }
                 _ => None,
             }
         };
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => submit().map(|id| {
                 let output = SelectionExit::default().with_id(Id::Object(id));
                 Message::Quit(Some(output))
             }),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<OperationSelect> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         let mut submit = || -> Option<radicle::cob::patch::PatchId> {
             match self.perform(Cmd::Submit) {
                 CmdResult::Submit(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(item.id().to_owned())
                 }
                 _ => None,
             }
         };
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(IssueOperation::Show.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('d'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(IssueOperation::Delete.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('e'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(IssueOperation::Edit.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('m'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(IssueOperation::Comment.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<AppHeader> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<LabeledContainer> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<PropertyList> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ContextBar> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Shortcuts> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }

added bin/commands/issue/realm/select/page.rs

@@ -0,0 +1,177 @@

 use std::collections::HashMap;
 use anyhow::Result;
 use tuirealm::{AttrValue, Attribute, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::common::cob::issue::Filter;
 use tui::common::context::Context;
 use tui::realm::ui::state::ItemState;
 use tui::realm::ui::theme::Theme;
 use tui::realm::ui::widget::context::{Progress, Shortcuts};
 use tui::realm::ui::widget::Widget;
 use tui::realm::ui::{layout, subscription};
 use tui::realm::ViewPage;
 use super::super::common;
 use super::{ui, Application, Cid, ListCid, Message, Mode};
 ///
 /// Home
 ///
 pub struct ListView {
     active_component: ListCid,
     subject: Mode,
     filter: Filter,
     shortcuts: HashMap<ListCid, Widget<Shortcuts>>,
 }
 impl ListView {
     pub fn new(subject: Mode, filter: Filter) -> Self {
         Self {
             active_component: ListCid::PatchBrowser,
             subject,
             filter,
             shortcuts: HashMap::default(),
         }
     }
     fn update_context(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let state = app.state(&Cid::List(ListCid::PatchBrowser))?;
         let progress = match ItemState::try_from(state) {
             Ok(state) => Progress::Step(
                 state
                     .selected()
                     .map(|s| s.saturating_add(1))
                     .unwrap_or_default(),
                 state.len(),
             ),
             Err(_) => Progress::None,
         };
         let context = common::ui::browse_context(context, theme, self.filter.clone(), progress);
         app.remount(Cid::List(ListCid::Context), context.to_boxed(), vec![])?;
         Ok(())
     }
     fn update_shortcuts(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: ListCid,
     ) -> Result<()> {
         if let Some(shortcuts) = self.shortcuts.get(&cid) {
             app.remount(
                 Cid::List(ListCid::Shortcuts),
                 shortcuts.clone().to_boxed(),
                 vec![],
             )?;
         }
         Ok(())
     }
 }
 impl ViewPage<Cid, Message> for ListView {
     fn mount(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let navigation = ui::list_navigation(theme);
         let header = tui::realm::ui::app_header(context, theme, Some(navigation)).to_boxed();
         app.remount(Cid::List(ListCid::Header), header, vec![])?;
         match self.subject {
             Mode::Id => {
                 let patch_browser =
                     ui::id_select(theme, context, self.filter.clone(), None).to_boxed();
                 self.shortcuts = patch_browser.as_ref().shortcuts();
                 app.remount(Cid::List(ListCid::PatchBrowser), patch_browser, vec![])?;
             }
             Mode::Operation => {
                 let patch_browser =
                     ui::operation_select(theme, context, self.filter.clone(), None).to_boxed();
                 self.shortcuts = patch_browser.as_ref().shortcuts();
                 app.remount(Cid::List(ListCid::PatchBrowser), patch_browser, vec![])?;
             }
         };
         app.active(&Cid::List(self.active_component.clone()))?;
         self.update_shortcuts(app, self.active_component.clone())?;
         self.update_context(app, context, theme)?;
         Ok(())
     }
     fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.umount(&Cid::List(ListCid::Header))?;
         app.umount(&Cid::List(ListCid::PatchBrowser))?;
         app.umount(&Cid::List(ListCid::Context))?;
         app.umount(&Cid::List(ListCid::Shortcuts))?;
         Ok(())
     }
     fn update(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         _message: Message,
     ) -> Result<Option<Message>> {
         self.update_context(app, context, theme)?;
         Ok(None)
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         let area = frame.size();
         let context_h = app
             .query(&Cid::List(ListCid::Context), Attribute::Height)
             .unwrap_or_default()
             .unwrap_or(AttrValue::Size(0))
             .unwrap_size();
         let shortcuts_h = 1u16;
         let layout = layout::default_page(area, context_h, shortcuts_h);
         app.view(
             &Cid::List(self.active_component.clone()),
             frame,
             layout.component,
         );
         app.view(&Cid::List(ListCid::Context), frame, layout.context);
         app.view(&Cid::List(ListCid::Shortcuts), frame, layout.shortcuts);
     }
     fn subscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.subscribe(
             &Cid::List(ListCid::Header),
             Sub::new(subscription::navigation_clause(), SubClause::Always),
         )?;
         Ok(())
     }
     fn unsubscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.unsubscribe(
             &Cid::List(ListCid::Header),
             subscription::navigation_clause(),
         )?;
         Ok(())
     }
 }

added bin/commands/issue/realm/select/ui.rs

@@ -0,0 +1,157 @@

 use std::collections::HashMap;
 use radicle::issue::{Issue, IssueId};
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State};
 use radicle_tui as tui;
 use tui::common::cob::issue::Filter;
 use tui::common::context::Context;
 use tui::realm::ui::cob::IssueItem;
 use tui::realm::ui::theme::{style, Theme};
 use tui::realm::ui::widget::container::Tabs;
 use tui::realm::ui::widget::context::Shortcuts;
 use tui::realm::ui::widget::label::{self};
 use tui::realm::ui::widget::{Widget, WidgetComponent};
 use super::super::common;
 use super::ListCid;
 pub struct IdSelect {
     theme: Theme,
     browser: Widget<common::ui::IssueBrowser>,
 }
 impl IdSelect {
     pub fn new(theme: Theme, browser: Widget<common::ui::IssueBrowser>) -> Self {
         Self { theme, browser }
     }
     pub fn items(&self) -> &Vec<IssueItem> {
         self.browser.items()
     }
     pub fn shortcuts(&self) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::PatchBrowser,
             tui::realm::ui::shortcuts(
                 &self.theme,
                 vec![
                     tui::realm::ui::shortcut(&self.theme, "enter", "select"),
                     tui::realm::ui::shortcut(&self.theme, "q", "quit"),
                 ],
             ),
         )]
         .iter()
         .cloned()
         .collect()
     }
 }
 impl WidgetComponent for IdSelect {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.browser.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.browser.view(frame, area);
     }
     fn state(&self) -> State {
         self.browser.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.browser.perform(cmd)
     }
 }
 pub struct OperationSelect {
     theme: Theme,
     browser: Widget<common::ui::IssueBrowser>,
 }
 impl OperationSelect {
     pub fn new(theme: Theme, browser: Widget<common::ui::IssueBrowser>) -> Self {
         Self { theme, browser }
     }
     pub fn items(&self) -> &Vec<IssueItem> {
         self.browser.items()
     }
     pub fn shortcuts(&self) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::PatchBrowser,
             tui::realm::ui::shortcuts(
                 &self.theme,
                 vec![
                     tui::realm::ui::shortcut(&self.theme, "enter", "show"),
                     tui::realm::ui::shortcut(&self.theme, "m", "comment"),
                     tui::realm::ui::shortcut(&self.theme, "e", "edit"),
                     tui::realm::ui::shortcut(&self.theme, "d", "delete"),
                     tui::realm::ui::shortcut(&self.theme, "q", "quit"),
                 ],
             ),
         )]
         .iter()
         .cloned()
         .collect()
     }
 }
 impl WidgetComponent for OperationSelect {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.browser.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.browser.view(frame, area);
     }
     fn state(&self) -> State {
         self.browser.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.browser.perform(cmd)
     }
 }
 pub fn list_navigation(theme: &Theme) -> Widget<Tabs> {
     tui::realm::ui::tabs(
         theme,
         vec![label::reversable("Patches").style(style::cyan())],
     )
 }
 pub fn id_select(
     theme: &Theme,
     context: &Context,
     filter: Filter,
     selected: Option<(IssueId, Issue)>,
 ) -> Widget<IdSelect> {
     let browser = Widget::new(common::ui::IssueBrowser::new(
         theme, context, filter, selected,
     ));
     Widget::new(IdSelect::new(theme.clone(), browser))
 }
 pub fn operation_select(
     theme: &Theme,
     context: &Context,
     filter: Filter,
     selected: Option<(IssueId, Issue)>,
 ) -> Widget<OperationSelect> {
     let browser = Widget::new(common::ui::IssueBrowser::new(
         theme, context, filter, selected,
     ));
     Widget::new(OperationSelect::new(theme.clone(), browser))
 }

added bin/commands/issue/realm/suite.rs

@@ -0,0 +1,354 @@

 #[path = "suite/event.rs"]
 mod event;
 #[path = "suite/page.rs"]
 mod page;
 #[path = "suite/ui.rs"]
 mod ui;
 use anyhow::Result;
 use radicle::cob::issue::IssueId;
 use tuirealm::application::PollStrategy;
 use tuirealm::event::Key;
 use tuirealm::{Application, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::common::cob;
 use tui::common::context::Context;
 use tui::realm::ui::subscription;
 use tui::realm::ui::theme::Theme;
 use tui::realm::{PageStack, Tui};
 use tui::Exit;
 use page::{IssuePage, ListPage};
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum ListCid {
     Header,
     IssueBrowser,
     Context,
     Shortcuts,
 }
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum IssueCid {
     Header,
     List,
     Details,
     Context,
     Form,
     Shortcuts,
 }
 /// All component ids known to this application.
 #[derive(Debug, Default, Eq, PartialEq, Clone, Hash)]
 pub enum Cid {
     List(ListCid),
     Issue(IssueCid),
     #[default]
     GlobalListener,
     Popup,
 }
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IssueCobMessage {
     Create {
         title: String,
         tags: String,
         assignees: String,
         description: String,
     },
 }
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IssueMessage {
     Show(Option<IssueId>),
     Changed(IssueId),
     Focus(IssueCid),
     Created(IssueId),
     Cob(IssueCobMessage),
     Reload(Option<IssueId>),
     OpenForm,
     HideForm,
     Leave(Option<IssueId>),
 }
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum PopupMessage {
     Info(String),
     Warning(String),
     Error(String),
     Hide,
 }
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub enum Message {
     Issue(IssueMessage),
     NavigationChanged(u16),
     FormSubmitted(String),
     Popup(PopupMessage),
     #[default]
     Tick,
     Quit,
     Batch(Vec<Message>),
 }
 #[allow(dead_code)]
 pub struct App {
     context: Context,
     pages: PageStack<Cid, Message>,
     theme: Theme,
     quit: bool,
 }
 /// Creates a new application using a tui-realm-application, mounts all
 /// components and sets focus to a default one.
 #[allow(dead_code)]
 impl App {
     pub fn new(context: Context) -> Self {
         Self {
             context,
             pages: PageStack::default(),
             theme: Theme::default(),
             quit: false,
         }
     }
     fn view_list(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
     ) -> Result<()> {
         let list = Box::new(ListPage::new(theme.clone()));
         self.pages.push(list, app, &self.context, theme)?;
         Ok(())
     }
     fn view_issue(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         id: Option<IssueId>,
         theme: &Theme,
     ) -> Result<()> {
         let repo = self.context.repository();
         match id {
             Some(id) => {
                 if let Some(issue) = cob::issue::find(repo, &id)? {
                     let view = Box::new(IssuePage::new(&self.context, theme, Some((id, issue))));
                     self.pages.push(view, app, &self.context, theme)?;
                     Ok(())
                 } else {
                     Err(anyhow::anyhow!(
                         "Could not mount 'page::IssueView'. Issue not found."
                     ))
                 }
             }
             None => {
                 let view = Box::new(IssuePage::new(&self.context, theme, None));
                 self.pages.push(view, app, &self.context, theme)?;
                 Ok(())
             }
         }
     }
     fn process(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         message: Message,
     ) -> Result<Option<Message>> {
         let theme = Theme::default();
         match message {
             Message::Batch(messages) => {
                 let mut results = vec![];
                 for message in messages {
                     if let Some(result) = self.process(app, message)? {
                         results.push(result);
                     }
                 }
                 match results.len() {
 => Ok(None),
 => Ok(Some(results[0].to_owned())),
                     _ => Ok(Some(Message::Batch(results))),
                 }
             }
             Message::Issue(IssueMessage::Cob(IssueCobMessage::Create {
                 title,
                 tags,
                 assignees,
                 description,
             })) => match self.create_issue(title, description, tags, assignees) {
                 Ok(id) => {
                     self.context.reload_issues();
                     Ok(Some(Message::Batch(vec![
                         Message::Issue(IssueMessage::HideForm),
                         Message::Issue(IssueMessage::Created(id)),
                     ])))
                 }
                 Err(err) => {
                     let error = format!("{:?}", err);
                     self.show_error_popup(app, &theme, &error)?;
                     Ok(None)
                 }
             },
             Message::Issue(IssueMessage::Show(id)) => {
                 self.view_issue(app, id, &theme)?;
                 Ok(None)
             }
             Message::Issue(IssueMessage::Leave(id)) => {
                 self.pages.pop(app)?;
                 Ok(Some(Message::Issue(IssueMessage::Reload(id))))
             }
             Message::Popup(PopupMessage::Info(info)) => {
                 self.show_info_popup(app, &theme, &info)?;
                 Ok(None)
             }
             Message::Popup(PopupMessage::Warning(warning)) => {
                 self.show_warning_popup(app, &theme, &warning)?;
                 Ok(None)
             }
             Message::Popup(PopupMessage::Error(error)) => {
                 self.show_error_popup(app, &theme, &error)?;
                 Ok(None)
             }
             Message::Popup(PopupMessage::Hide) => {
                 self.hide_popup(app)?;
                 Ok(None)
             }
             Message::Quit => {
                 self.quit = true;
                 Ok(None)
             }
             _ => self
                 .pages
                 .peek_mut()?
                 .update(app, &self.context, &theme, message),
         }
     }
     fn show_info_popup(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
         message: &str,
     ) -> Result<()> {
         let popup = tui::realm::ui::info(theme, message);
         app.remount(Cid::Popup, popup.to_boxed(), vec![])?;
         app.active(&Cid::Popup)?;
         Ok(())
     }
     fn show_warning_popup(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
         message: &str,
     ) -> Result<()> {
         let popup = tui::realm::ui::warning(theme, message);
         app.remount(Cid::Popup, popup.to_boxed(), vec![])?;
         app.active(&Cid::Popup)?;
         Ok(())
     }
     fn show_error_popup(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
         message: &str,
     ) -> Result<()> {
         let popup = tui::realm::ui::error(theme, message);
         app.remount(Cid::Popup, popup.to_boxed(), vec![])?;
         app.active(&Cid::Popup)?;
         Ok(())
     }
     fn hide_popup(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.blur()?;
         app.umount(&Cid::Popup)?;
         Ok(())
     }
     fn create_issue(
         &mut self,
         title: String,
         description: String,
         labels: String,
         assignees: String,
     ) -> Result<IssueId> {
         let repository = self.context.repository();
         let signer = self.context.signer().as_ref().unwrap();
         let labels = cob::parse_labels(labels)?;
         let assignees = cob::parse_assignees(assignees)?;
         cob::issue::create(
             repository,
             signer,
             title,
             description,
             labels.as_slice(),
             assignees.as_slice(),
         )
     }
 }
 impl Tui<Cid, Message, ()> for App {
     fn init(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         self.view_list(app, &self.theme.clone())?;
         // Add global key listener and subscribe to key events
         let global = tui::realm::ui::global_listener().to_boxed();
         app.mount(
             Cid::GlobalListener,
             global,
             vec![Sub::new(
                 subscription::quit_clause(Key::Char('q')),
                 SubClause::Always,
             )],
         )?;
         Ok(())
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         if let Ok(page) = self.pages.peek_mut() {
             page.view(app, frame);
         }
         if app.mounted(&Cid::Popup) {
             app.view(&Cid::Popup, frame, frame.size());
         }
     }
     fn update(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<bool> {
         match app.tick(PollStrategy::Once) {
             Ok(messages) if !messages.is_empty() => {
                 for message in messages {
                     let mut msg = Some(message);
                     while msg.is_some() {
                         msg = self.process(app, msg.unwrap())?;
                     }
                 }
                 Ok(true)
             }
             _ => Ok(false),
         }
     }
     fn exit(&self) -> Option<Exit<()>> {
         if self.quit {
             return Some(Exit { value: None });
         }
         None
     }
 }

added bin/commands/issue/realm/suite/event.rs

@@ -0,0 +1,322 @@

 use radicle::cob::issue::IssueId;
 use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection, Position};
 use tuirealm::event::{Event, Key, KeyEvent, KeyModifiers};
 use tuirealm::{MockComponent, NoUserEvent, State, StateValue};
 use radicle_tui as tui;
 use tui::realm::ui::state::ItemState;
 use tui::realm::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer, Popup};
 use tui::realm::ui::widget::context::{ContextBar, Shortcuts};
 use tui::realm::ui::widget::form::Form;
 use tui::realm::ui::widget::list::PropertyList;
 use tui::realm::ui::widget::Widget;
 use super::ui;
 use super::{IssueCid, IssueMessage, Message, PopupMessage};
 /// Since the framework does not know the type of messages that are being
 /// passed around in the app, the following handlers need to be implemented for
 /// each component used.
 ///
 /// TODO: should handle `Event::WindowResize`, which is not emitted by `termion`.
 impl tuirealm::Component<Message, NoUserEvent> for Widget<GlobalListener> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent {
                 code: Key::Char('q'),
                 ..
             }) => Some(Message::Quit),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<AppHeader> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Tab, .. }) => {
                 match self.perform(Cmd::Move(MoveDirection::Right)) {
                     CmdResult::Changed(State::One(StateValue::U16(index))) => {
                         Some(Message::NavigationChanged(index))
                     }
                     _ => None,
                 }
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ui::LargeList> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {
                 let selected = ItemState::try_from(self.state()).ok()?.selected()?;
                 let item = self.items().get(selected)?;
                 Some(Message::Issue(IssueMessage::Leave(Some(
                     item.id().to_owned(),
                 ))))
             }
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => match self.perform(Cmd::Move(MoveDirection::Up)) {
                 CmdResult::Changed(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(Message::Issue(IssueMessage::Changed(item.id().to_owned())))
                 }
                 _ => None,
             },
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => match self.perform(Cmd::Move(MoveDirection::Down)) {
                 CmdResult::Changed(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(Message::Issue(IssueMessage::Changed(item.id().to_owned())))
                 }
                 _ => None,
             },
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => Some(Message::Issue(IssueMessage::Focus(IssueCid::Details))),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('o'),
                 ..
             }) => Some(Message::Issue(IssueMessage::OpenForm)),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ui::IssueDetails> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Scroll(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Scroll(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {
                 Some(Message::Issue(IssueMessage::Focus(IssueCid::List)))
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Form> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent {
                 code: Key::Left, ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Left));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Right, ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Right));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent { code: Key::Up, .. }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Home, ..
             }) => {
                 self.perform(Cmd::GoTo(Position::Begin));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent { code: Key::End, .. }) => {
                 self.perform(Cmd::GoTo(Position::End));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Delete, ..
             }) => {
                 self.perform(Cmd::Cancel);
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Backspace,
                 ..
             }) => {
                 self.perform(Cmd::Delete);
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => {
                 self.perform(Cmd::Custom(Form::CMD_NEWLINE));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Char('s'),
                 modifiers: KeyModifiers::CONTROL,
             }) => {
                 self.perform(Cmd::Submit);
                 self.query(tuirealm::Attribute::Custom(Form::PROP_ID))
                     .map(|cid| Message::FormSubmitted(cid.unwrap_string()))
             }
             Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {
                 Some(Message::Issue(IssueMessage::HideForm))
             }
             Event::Keyboard(KeyEvent {
                 code: Key::BackTab, ..
             }) => {
                 self.perform(Cmd::Custom(Form::CMD_FOCUS_PREVIOUS));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent { code: Key::Tab, .. }) => {
                 self.perform(Cmd::Custom(Form::CMD_FOCUS_NEXT));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Char(ch),
                 modifiers: KeyModifiers::SHIFT,
             }) => {
                 self.perform(Cmd::Type(ch.to_ascii_uppercase()));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Char('v'),
                 modifiers: KeyModifiers::CONTROL,
             }) => {
                 self.perform(Cmd::Custom(Form::CMD_PASTE));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Char(ch),
                 ..
             }) => {
                 self.perform(Cmd::Type(ch));
                 Some(Message::Tick)
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ui::IssueBrowser> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         let mut submit = || -> Option<IssueId> {
             match self.perform(Cmd::Submit) {
                 CmdResult::Submit(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(item.id().to_owned())
                 }
                 _ => None,
             }
         };
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Char('o'),
                 ..
             }) => {
                 let id = submit();
                 Some(Message::Batch(vec![
                     Message::Issue(IssueMessage::Show(id)),
                     Message::Issue(IssueMessage::OpenForm),
                 ]))
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => {
                 let id = submit();
                 if id.is_some() {
                     Some(Message::Issue(IssueMessage::Show(id)))
                 } else {
                     None
                 }
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Popup> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {
                 Some(Message::Popup(PopupMessage::Hide))
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<LabeledContainer> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<PropertyList> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ContextBar> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Shortcuts> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }

added bin/commands/issue/realm/suite/page.rs

@@ -0,0 +1,569 @@

 use std::collections::HashMap;
 use anyhow::Result;
 use radicle::cob::issue::{Issue, IssueId};
 use tuirealm::event::Key;
 use tuirealm::{AttrValue, Attribute, Frame, NoUserEvent, State, StateValue, Sub, SubClause};
 use radicle_tui as tui;
 use tui::common::cob;
 use tui::common::context::Context;
 use tui::realm::ui::layout;
 use tui::realm::ui::state::ItemState;
 use tui::realm::ui::theme::Theme;
 use tui::realm::ui::widget::context::{Progress, Shortcuts};
 use tui::realm::ui::widget::Widget;
 use tui::realm::ViewPage;
 use super::{
     Application, Cid, IssueCid, IssueCobMessage, IssueMessage, ListCid, Message, PopupMessage,
 };
 use super::subscription;
 use super::ui;
 ///
 /// Home
 ///
 pub struct ListPage {
     active_component: ListCid,
     shortcuts: HashMap<ListCid, Widget<Shortcuts>>,
 }
 impl ListPage {
     pub fn new(theme: Theme) -> Self {
         let shortcuts = Self::build_shortcuts(&theme);
         Self {
             active_component: ListCid::IssueBrowser,
             shortcuts,
         }
     }
     fn activate(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: ListCid,
     ) -> Result<()> {
         self.active_component = cid;
         let cid = Cid::List(self.active_component.clone());
         app.active(&cid)?;
         app.attr(&cid, Attribute::Focus, AttrValue::Flag(true))?;
         Ok(())
     }
     fn build_shortcuts(theme: &Theme) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::IssueBrowser,
             tui::realm::ui::shortcuts(
                 theme,
                 vec![
                     tui::realm::ui::shortcut(theme, "tab", "section"),
                     tui::realm::ui::shortcut(theme, "↑/↓", "navigate"),
                     tui::realm::ui::shortcut(theme, "enter", "show"),
                     tui::realm::ui::shortcut(theme, "o", "open"),
                     tui::realm::ui::shortcut(theme, "q", "quit"),
                 ],
             ),
         )]
         .iter()
         .cloned()
         .collect()
     }
     fn update_context(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let state = app.state(&Cid::List(ListCid::IssueBrowser))?;
         let progress = match ItemState::try_from(state) {
             Ok(state) => Progress::Step(
                 state
                     .selected()
                     .map(|s| s.saturating_add(1))
                     .unwrap_or_default(),
                 state.len(),
             ),
             Err(_) => Progress::None,
         };
         let context = ui::browse_context(context, theme, progress);
         app.remount(Cid::List(ListCid::Context), context.to_boxed(), vec![])?;
         Ok(())
     }
     fn update_shortcuts(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: ListCid,
     ) -> Result<()> {
         if let Some(shortcuts) = self.shortcuts.get(&cid) {
             app.remount(
                 Cid::List(ListCid::Shortcuts),
                 shortcuts.clone().to_boxed(),
                 vec![],
             )?;
         }
         Ok(())
     }
 }
 impl ViewPage<Cid, Message> for ListPage {
     fn mount(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let navigation = ui::list_navigation(theme);
         let header = tui::realm::ui::app_header(context, theme, Some(navigation)).to_boxed();
         let issue_browser = ui::issues(context, theme, None).to_boxed();
         app.remount(Cid::List(ListCid::Header), header, vec![])?;
         app.remount(Cid::List(ListCid::IssueBrowser), issue_browser, vec![])?;
         app.active(&Cid::List(self.active_component.clone()))?;
         self.update_shortcuts(app, self.active_component.clone())?;
         self.update_context(app, context, theme)?;
         Ok(())
     }
     fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.umount(&Cid::List(ListCid::Header))?;
         app.umount(&Cid::List(ListCid::IssueBrowser))?;
         app.umount(&Cid::List(ListCid::Context))?;
         app.umount(&Cid::List(ListCid::Shortcuts))?;
         Ok(())
     }
     fn update(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         message: Message,
     ) -> Result<Option<Message>> {
         if let Message::Issue(IssueMessage::Reload(id)) = message {
             let selected = match id {
                 Some(id) => cob::issue::find(context.repository(), &id)?.map(|issue| (id, issue)),
                 _ => None,
             };
             let issue_browser = ui::issues(context, theme, selected).to_boxed();
             app.remount(Cid::List(ListCid::IssueBrowser), issue_browser, vec![])?;
             self.activate(app, ListCid::IssueBrowser)?;
         }
         self.update_context(app, context, theme)?;
         Ok(None)
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         let area = frame.size();
         let context_h = app
             .query(&Cid::List(ListCid::Context), Attribute::Height)
             .unwrap_or_default()
             .unwrap_or(AttrValue::Size(0))
             .unwrap_size();
         let shortcuts_h = 1u16;
         let layout = layout::full_page(area, context_h, shortcuts_h);
         app.view(&Cid::List(ListCid::Header), frame, layout.navigation);
         app.view(
             &Cid::List(self.active_component.clone()),
             frame,
             layout.component,
         );
         app.view(&Cid::List(ListCid::Shortcuts), frame, layout.shortcuts);
     }
     fn subscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.subscribe(
             &Cid::List(ListCid::Header),
             Sub::new(subscription::navigation_clause(), SubClause::Always),
         )?;
         Ok(())
     }
     fn unsubscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.unsubscribe(
             &Cid::List(ListCid::Header),
             subscription::navigation_clause(),
         )?;
         Ok(())
     }
 }
 ///
 /// Issue detail page
 ///
 pub struct IssuePage {
     issue: Option<(IssueId, Issue)>,
     active_component: IssueCid,
     shortcuts: HashMap<IssueCid, Widget<Shortcuts>>,
 }
 impl IssuePage {
     pub fn new(_context: &Context, theme: &Theme, issue: Option<(IssueId, Issue)>) -> Self {
         let shortcuts = Self::build_shortcuts(theme);
         let active_component = IssueCid::List;
         Self {
             issue,
             active_component,
             shortcuts,
         }
     }
     fn activate(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: IssueCid,
     ) -> Result<()> {
         self.active_component = cid;
         let cid = Cid::Issue(self.active_component.clone());
         app.active(&cid)?;
         app.attr(&cid, Attribute::Focus, AttrValue::Flag(true))?;
         Ok(())
     }
     fn build_shortcuts(theme: &Theme) -> HashMap<IssueCid, Widget<Shortcuts>> {
         [
             (
                 IssueCid::List,
                 tui::realm::ui::shortcuts(
                     theme,
                     vec![
                         tui::realm::ui::shortcut(theme, "esc", "back"),
                         tui::realm::ui::shortcut(theme, "↑/↓", "navigate"),
                         tui::realm::ui::shortcut(theme, "enter", "show"),
                         tui::realm::ui::shortcut(theme, "o", "open"),
                         tui::realm::ui::shortcut(theme, "q", "quit"),
                     ],
                 ),
             ),
             (
                 IssueCid::Details,
                 tui::realm::ui::shortcuts(
                     theme,
                     vec![
                         tui::realm::ui::shortcut(theme, "esc", "back"),
                         tui::realm::ui::shortcut(theme, "↑/↓", "scroll"),
                         tui::realm::ui::shortcut(theme, "q", "quit"),
                     ],
                 ),
             ),
             (
                 IssueCid::Form,
                 tui::realm::ui::shortcuts(
                     theme,
                     vec![
                         tui::realm::ui::shortcut(theme, "esc", "back"),
                         tui::realm::ui::shortcut(theme, "shift + tab / tab", "navigate"),
                         tui::realm::ui::shortcut(theme, "ctrl + s", "submit"),
                     ],
                 ),
             ),
         ]
         .iter()
         .cloned()
         .collect()
     }
     fn update_context(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         cid: IssueCid,
     ) -> Result<()> {
         let context = match cid {
             IssueCid::List => {
                 let state = app.state(&Cid::Issue(IssueCid::List))?;
                 let progress = match state {
                     State::Tup2((StateValue::Usize(step), StateValue::Usize(total))) => {
                         Progress::Step(step.saturating_add(1), total)
                     }
                     _ => Progress::None,
                 };
                 let context = ui::browse_context(context, theme, progress);
                 Some(context)
             }
             IssueCid::Details => {
                 let state = app.state(&Cid::Issue(IssueCid::Details))?;
                 let progress = match state {
                     State::One(StateValue::Usize(scroll)) => Progress::Percentage(scroll),
                     _ => Progress::None,
                 };
                 let context = ui::description_context(context, theme, progress);
                 Some(context)
             }
             IssueCid::Form => {
                 let context = ui::form_context(context, theme, Progress::None);
                 Some(context)
             }
             _ => None,
         };
         if let Some(context) = context {
             app.remount(Cid::Issue(IssueCid::Context), context.to_boxed(), vec![])?;
         }
         Ok(())
     }
     fn update_shortcuts(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: IssueCid,
     ) -> Result<()> {
         if let Some(shortcuts) = self.shortcuts.get(&cid) {
             app.remount(
                 Cid::Issue(IssueCid::Shortcuts),
                 shortcuts.clone().to_boxed(),
                 vec![],
             )?;
         }
         Ok(())
     }
 }
 impl ViewPage<Cid, Message> for IssuePage {
     fn mount(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let navigation = ui::list_navigation(theme);
         let header = tui::realm::ui::app_header(context, theme, Some(navigation)).to_boxed();
         let list = ui::list(context, theme, self.issue.clone()).to_boxed();
         app.remount(Cid::Issue(IssueCid::Header), header, vec![])?;
         app.remount(Cid::Issue(IssueCid::List), list, vec![])?;
         if let Some((id, issue)) = &self.issue {
             let comments = issue.comments().collect::<Vec<_>>();
             let details = ui::details(
                 context,
                 theme,
                 (*id, issue.clone()),
                 comments.first().copied(),
             )
             .to_boxed();
             app.remount(Cid::Issue(IssueCid::Details), details, vec![])?;
         }
         app.active(&Cid::Issue(self.active_component.clone()))?;
         self.update_shortcuts(app, self.active_component.clone())?;
         self.update_context(app, context, theme, self.active_component.clone())?;
         Ok(())
     }
     fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.umount(&Cid::Issue(IssueCid::Header))?;
         app.umount(&Cid::Issue(IssueCid::List))?;
         app.umount(&Cid::Issue(IssueCid::Context))?;
         app.umount(&Cid::Issue(IssueCid::Shortcuts))?;
         if app.mounted(&Cid::Issue(IssueCid::Details)) {
             app.umount(&Cid::Issue(IssueCid::Details))?;
         }
         if app.mounted(&Cid::Issue(IssueCid::Form)) {
             app.umount(&Cid::Issue(IssueCid::Form))?;
         }
         Ok(())
     }
     fn update(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         message: Message,
     ) -> Result<Option<Message>> {
         match message {
             Message::Issue(IssueMessage::Created(id)) => {
                 let repo = context.repository();
                 if let Some(issue) = cob::issue::find(repo, &id)? {
                     self.issue = Some((id, issue.clone()));
                     let list = ui::list(context, theme, self.issue.clone()).to_boxed();
                     let comments = issue.comments().collect::<Vec<_>>();
                     let details = ui::details(
                         context,
                         theme,
                         (id, issue.clone()),
                         comments.first().copied(),
                     )
                     .to_boxed();
                     app.remount(Cid::Issue(IssueCid::List), list, vec![])?;
                     app.remount(Cid::Issue(IssueCid::Details), details, vec![])?;
                 }
             }
             Message::Issue(IssueMessage::Changed(id)) => {
                 let repo = context.repository();
                 if let Some(issue) = cob::issue::find(repo, &id)? {
                     self.issue = Some((id, issue.clone()));
                     let comments = issue.comments().collect::<Vec<_>>();
                     let details = ui::details(
                         context,
                         theme,
                         (id, issue.clone()),
                         comments.first().copied(),
                     )
                     .to_boxed();
                     app.remount(Cid::Issue(IssueCid::Details), details, vec![])?;
                 }
             }
             Message::Issue(IssueMessage::Focus(cid)) => {
                 self.activate(app, cid)?;
                 self.update_shortcuts(app, self.active_component.clone())?;
             }
             Message::Issue(IssueMessage::OpenForm) => {
                 let new_form = ui::new_form(context, theme).to_boxed();
                 let list = ui::list(context, theme, None).to_boxed();
                 app.remount(Cid::Issue(IssueCid::List), list, vec![])?;
                 app.remount(Cid::Issue(IssueCid::Form), new_form, vec![])?;
                 app.active(&Cid::Issue(IssueCid::Form))?;
                 app.unsubscribe(
                     &Cid::GlobalListener,
                     subscription::quit_clause(Key::Char('q')),
                 )?;
                 return Ok(Some(Message::Issue(IssueMessage::Focus(IssueCid::Form))));
             }
             Message::Issue(IssueMessage::HideForm) => {
                 app.umount(&Cid::Issue(IssueCid::Form))?;
                 let list = ui::list(context, theme, self.issue.clone()).to_boxed();
                 app.remount(Cid::Issue(IssueCid::List), list, vec![])?;
                 app.subscribe(
                     &Cid::GlobalListener,
                     Sub::new(subscription::quit_clause(Key::Char('q')), SubClause::Always),
                 )?;
                 if self.issue.is_none() {
                     return Ok(Some(Message::Issue(IssueMessage::Leave(None))));
                 }
                 return Ok(Some(Message::Issue(IssueMessage::Focus(IssueCid::List))));
             }
             Message::FormSubmitted(id) => {
                 if id == ui::FORM_ID_EDIT {
                     let state = app.state(&Cid::Issue(IssueCid::Form))?;
                     if let State::Linked(mut states) = state {
                         let mut missing_values = vec![];
                         let title = match states.front() {
                             Some(State::One(StateValue::String(title))) if !title.is_empty() => {
                                 Some(title.clone())
                             }
                             _ => None,
                         };
                         states.pop_front();
                         let tags = match states.front() {
                             Some(State::One(StateValue::String(tags))) => Some(tags.clone()),
                             _ => Some(String::from("[]")),
                         };
                         states.pop_front();
                         let assignees = match states.front() {
                             Some(State::One(StateValue::String(assignees))) => {
                                 Some(assignees.clone())
                             }
                             _ => Some(String::from("[]")),
                         };
                         states.pop_front();
                         let description = match states.front() {
                             Some(State::One(StateValue::String(description)))
                                 if !description.is_empty() =>
                             {
                                 Some(description.clone())
                             }
                             _ => None,
                         };
                         states.pop_front();
                         if title.is_none() {
                             missing_values.push("title");
                         }
                         if description.is_none() {
                             missing_values.push("description");
                         }
                         // show error popup if missing.
                         if !missing_values.is_empty() {
                             let error = format!("Missing fields: {:?}", missing_values);
                             return Ok(Some(Message::Popup(PopupMessage::Error(error))));
                         } else {
                             return Ok(Some(Message::Issue(IssueMessage::Cob(
                                 IssueCobMessage::Create {
                                     title: title.unwrap(),
                                     tags: tags.unwrap(),
                                     assignees: assignees.unwrap(),
                                     description: description.unwrap(),
                                 },
                             ))));
                         }
                     }
                 }
             }
             _ => {}
         }
         self.update_context(app, context, theme, self.active_component.clone())?;
         Ok(None)
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         let area = frame.size();
         let shortcuts_h = 1u16;
         let layout = layout::issue_page(area, shortcuts_h);
         app.view(&Cid::Issue(IssueCid::Header), frame, layout.header);
         app.view(&Cid::Issue(IssueCid::List), frame, layout.left);
         if app.mounted(&Cid::Issue(IssueCid::Form)) {
             app.view(&Cid::Issue(IssueCid::Form), frame, layout.right);
         } else if app.mounted(&Cid::Issue(IssueCid::Details)) {
             app.view(&Cid::Issue(IssueCid::Details), frame, layout.right);
         }
         app.view(&Cid::Issue(IssueCid::Context), frame, layout.context);
         app.view(&Cid::Issue(IssueCid::Shortcuts), frame, layout.shortcuts);
     }
     fn subscribe(&self, _app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         Ok(())
     }
     fn unsubscribe(&self, _app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         Ok(())
     }
 }

added bin/commands/issue/realm/suite/ui.rs

@@ -0,0 +1,435 @@

 use radicle::node::AliasStore;
 use radicle::cob::thread::Comment;
 use radicle::cob::thread::CommentId;
 use radicle::cob::issue::Issue;
 use radicle::cob::issue::IssueId;
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::{Constraint, Direction, Layout, Rect};
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State};
 use radicle_tui as tui;
 use tui::common::context::Context;
 use tui::realm::ui::cob;
 use tui::realm::ui::cob::IssueItem;
 use tui::realm::ui::theme::style;
 use tui::realm::ui::theme::Theme;
 use tui::realm::ui::widget::container::{Container, Tabs};
 use tui::realm::ui::widget::context::{ContextBar, Progress};
 use tui::realm::ui::widget::form::{Form, TextArea, TextField};
 use tui::realm::ui::widget::label::{self, Textarea};
 use tui::realm::ui::widget::list::{ColumnWidth, List, Property, Table};
 use tui::realm::ui::widget::{Widget, WidgetComponent};
 pub const FORM_ID_EDIT: &str = "edit-form";
 pub struct IssueBrowser {
     items: Vec<IssueItem>,
     table: Widget<Table<IssueItem, 7>>,
 }
 impl IssueBrowser {
     pub fn new(context: &Context, theme: &Theme, selected: Option<(IssueId, Issue)>) -> Self {
         let header = [
             label::header(" ● "),
             label::header("ID"),
             label::header("Title"),
             label::header("Author"),
             label::header("Tags"),
             label::header("Assignees"),
             label::header("Opened"),
         ];
         let widths = [
             ColumnWidth::Fixed(3),
             ColumnWidth::Fixed(7),
             ColumnWidth::Grow,
             ColumnWidth::Fixed(21),
             ColumnWidth::Fixed(25),
             ColumnWidth::Fixed(21),
             ColumnWidth::Fixed(18),
         ];
         let repo = context.repository();
         let mut items = vec![];
         let issues = context.issues().as_ref().unwrap();
         for (id, issue) in issues {
             if let Ok(item) = IssueItem::try_from((context.profile(), repo, *id, issue.clone())) {
                 items.push(item);
             }
         }
         items.sort_by(|a, b| b.timestamp().cmp(a.timestamp()));
         items.sort_by(|a, b| b.state().cmp(a.state()));
         let selected = match selected {
             Some((id, issue)) => Some(IssueItem::from((context.profile(), repo, id, issue))),
             _ => items.first().cloned(),
         };
         let table = Widget::new(Table::new(&items, selected, header, widths, theme.clone()));
         Self { items, table }
     }
     pub fn items(&self) -> &Vec<IssueItem> {
         &self.items
     }
 }
 impl WidgetComponent for IssueBrowser {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.table.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.table.view(frame, area);
     }
     fn state(&self) -> State {
         self.table.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.table.perform(cmd)
     }
 }
 pub struct LargeList {
     items: Vec<IssueItem>,
     list: Widget<Container>,
 }
 impl LargeList {
     pub fn new(context: &Context, theme: &Theme, selected: Option<(IssueId, Issue)>) -> Self {
         let repo = context.repository();
         let issues = context.issues().as_ref().unwrap();
         let mut items = issues
             .iter()
             .map(|(id, issue)| IssueItem::from((context.profile(), repo, *id, issue.clone())))
             .collect::<Vec<_>>();
         items.sort_by(|a, b| b.timestamp().cmp(a.timestamp()));
         items.sort_by(|a, b| b.state().cmp(a.state()));
         let selected =
             selected.map(|(id, issue)| IssueItem::from((context.profile(), repo, id, issue)));
         let list = Widget::new(List::new(&items, selected, theme.clone()));
         let container = tui::realm::ui::container(theme, list.to_boxed());
         Self {
             items,
             list: container,
         }
     }
     pub fn items(&self) -> &Vec<IssueItem> {
         &self.items
     }
 }
 impl WidgetComponent for LargeList {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.list.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.list.view(frame, area);
     }
     fn state(&self) -> State {
         self.list.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.list.perform(cmd)
     }
 }
 pub struct IssueHeader {
     container: Widget<Container>,
 }
 impl IssueHeader {
     pub fn new(context: &Context, theme: &Theme, issue: (IssueId, Issue)) -> Self {
         let repo = context.repository();
         let (id, issue) = issue;
         let author = issue.author();
         let author = author.id();
         let alias = context.profile().aliases().alias(author);
         let by_you = *author == context.profile().did();
         let item = IssueItem::from((context.profile(), repo, id, issue.clone()));
         let title = Property::new(label::property("Title"), label::default(item.title()));
         let author = match alias {
             Some(_) => label::alias(&cob::format_author(issue.author().id(), &alias, by_you)),
             None => label::did(&cob::format_author(issue.author().id(), &alias, by_you)),
         };
         let author = Property::new(label::property("Author"), author);
         let issue_id = Property::new(
             label::property("Issue"),
             label::default(&id.to_string()).style(style::gray()),
         );
         let labels = Property::new(
             label::property("Labels"),
             label::labels(&cob::format_labels(item.labels())),
         );
         let assignees = Property::new(
             label::property("Assignees"),
             label::did(&cob::format_assignees(
                 &item
                     .assignees()
                     .iter()
                     .map(|item| (item.did(), item.alias(), item.is_you()))
                     .collect::<Vec<_>>(),
             )),
         );
         let state = Property::new(
             label::property("Status"),
             label::default(&item.state().to_string()),
         );
         let table = tui::realm::ui::property_table(
             theme,
             vec![
                 Widget::new(title),
                 Widget::new(issue_id),
                 Widget::new(author),
                 Widget::new(labels),
                 Widget::new(assignees),
                 Widget::new(state),
             ],
         );
         let container = tui::realm::ui::container(theme, table.to_boxed());
         Self { container }
     }
 }
 impl WidgetComponent for IssueHeader {
     fn view(&mut self, _properties: &Props, frame: &mut Frame, area: Rect) {
         self.container.view(frame, area);
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 pub struct IssueDetails {
     header: Widget<IssueHeader>,
     description: Widget<CommentBody>,
 }
 impl IssueDetails {
     pub fn new(
         context: &Context,
         theme: &Theme,
         issue: (IssueId, Issue),
         description: Option<(&CommentId, &Comment)>,
     ) -> Self {
         Self {
             header: header(context, theme, issue),
             description: self::description(context, theme, description),
         }
     }
 }
 impl WidgetComponent for IssueDetails {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         let layout = Layout::default()
             .direction(Direction::Vertical)
             .constraints([Constraint::Length(8), Constraint::Min(1)])
             .split(area);
         self.header.view(frame, layout[0]);
         self.description
             .attr(Attribute::Focus, AttrValue::Flag(focus));
         self.description.view(frame, layout[1]);
     }
     fn state(&self) -> State {
         self.description.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.description.perform(cmd)
     }
 }
 pub struct CommentBody {
     textarea: Widget<Container>,
 }
 impl CommentBody {
     pub fn new(_context: &Context, theme: &Theme, comment: Option<(&CommentId, &Comment)>) -> Self {
         let content = match comment {
             Some((_, comment)) => comment.body().to_string(),
             None => String::new(),
         };
         let textarea = Widget::new(Textarea::default())
             .content(AttrValue::String(content))
             .style(style::reset());
         let textarea = tui::realm::ui::container(theme, textarea.to_boxed());
         Self { textarea }
     }
 }
 impl WidgetComponent for CommentBody {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.textarea.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.textarea.view(frame, area);
     }
     fn state(&self) -> State {
         self.textarea.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.textarea.perform(cmd)
     }
 }
 pub fn list_navigation(theme: &Theme) -> Widget<Tabs> {
     tui::realm::ui::tabs(
         theme,
         vec![label::reversable("Issues").style(style::magenta())],
     )
 }
 pub fn list(
     context: &Context,
     theme: &Theme,
     issue: Option<(IssueId, Issue)>,
 ) -> Widget<LargeList> {
     let list = LargeList::new(context, theme, issue);
     Widget::new(list)
 }
 pub fn header(context: &Context, theme: &Theme, issue: (IssueId, Issue)) -> Widget<IssueHeader> {
     let header = IssueHeader::new(context, theme, issue);
     Widget::new(header)
 }
 pub fn description(
     context: &Context,
     theme: &Theme,
     comment: Option<(&CommentId, &Comment)>,
 ) -> Widget<CommentBody> {
     let body = CommentBody::new(context, theme, comment);
     Widget::new(body)
 }
 pub fn new_form(_context: &Context, theme: &Theme) -> Widget<Form> {
     use tuirealm::props::Layout;
     let title = Widget::new(TextField::new(theme.clone(), "Title")).to_boxed();
     let tags = Widget::new(TextField::new(theme.clone(), "Labels (bug, ...)")).to_boxed();
     let assignees = Widget::new(TextField::new(
         theme.clone(),
         "Assignees (z6MkvAdxCp1oLVVTsqYvev9YrhSN3gBQNUSM45hhy4pgkexk, ...)",
     ))
     .to_boxed();
     let description = Widget::new(TextArea::new(theme.clone(), "Description")).to_boxed();
     let inputs: Vec<Box<dyn MockComponent>> = vec![title, tags, assignees, description];
     let layout = Layout::default().constraints(
         [
             Constraint::Length(3),
             Constraint::Length(3),
             Constraint::Length(3),
             Constraint::Min(3),
         ]
         .as_ref(),
     );
     Widget::new(Form::new(theme.clone(), inputs))
         .custom(Form::PROP_ID, AttrValue::String(String::from(FORM_ID_EDIT)))
         .layout(layout)
 }
 pub fn details(
     context: &Context,
     theme: &Theme,
     issue: (IssueId, Issue),
     comment: Option<(&CommentId, &Comment)>,
 ) -> Widget<IssueDetails> {
     let discussion = IssueDetails::new(context, theme, issue, comment);
     Widget::new(discussion)
 }
 pub fn browse_context(context: &Context, theme: &Theme, progress: Progress) -> Widget<ContextBar> {
     use radicle::cob::issue::State;
     let issues = context.issues().as_ref().unwrap();
     let open = issues
         .iter()
         .filter(|issue| *issue.1.state() == State::Open)
         .collect::<Vec<_>>()
         .len();
     let closed = issues
         .iter()
         .filter(|issue| *issue.1.state() != State::Open)
         .collect::<Vec<_>>()
         .len();
     tui::realm::ui::widget::context::bar(
         theme,
         "Browse",
         "",
         "",
         &format!("{open} open | {closed} closed"),
         &progress.to_string(),
     )
 }
 pub fn description_context(
     _context: &Context,
     theme: &Theme,
     progress: Progress,
 ) -> Widget<ContextBar> {
     tui::realm::ui::widget::context::bar(theme, "Show", "", "", "", &progress.to_string())
 }
 pub fn form_context(_context: &Context, theme: &Theme, progress: Progress) -> Widget<ContextBar> {
     tui::realm::ui::widget::context::bar(theme, "Open", "", "", "", &progress.to_string())
         .custom(ContextBar::PROP_EDIT_MODE, AttrValue::Flag(true))
 }
 pub fn issues(
     context: &Context,
     theme: &Theme,
     selected: Option<(IssueId, Issue)>,
 ) -> Widget<IssueBrowser> {
     Widget::new(IssueBrowser::new(context, theme, selected))
 }

deleted bin/commands/issue/select.rs

@@ -1,235 +0,0 @@

 #[path = "select/event.rs"]
 mod event;
 #[path = "select/page.rs"]
 mod page;
 #[path = "select/ui.rs"]
 mod ui;
 use std::fmt::Display;
 use std::hash::Hash;
 use anyhow::Result;
 use serde::{Serialize, Serializer};
 use tuirealm::application::PollStrategy;
 use tuirealm::event::Key;
 use tuirealm::{Application, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::cob::issue::Filter;
 use tui::context::Context;
 use tui::ui::subscription;
 use tui::ui::theme::Theme;
 use tui::{Exit, PageStack, SelectionExit, Tui};
 use page::ListView;
 /// Wrapper around radicle's `PatchId` that serializes
 /// to a human-readable string.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PatchId(radicle::cob::patch::PatchId);
 impl From<radicle::cob::patch::PatchId> for PatchId {
     fn from(value: radicle::cob::patch::PatchId) -> Self {
         PatchId(value)
     }
 }
 impl Display for PatchId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.0)
     }
 }
 impl Serialize for PatchId {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
         serializer.serialize_str(&format!("{}", *self.0))
     }
 }
 /// The application's subject. It tells the application
 /// which widgets to render and which output to produce.
 ///
 /// Depends on CLI arguments given by the user.
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum Mode {
     #[default]
     Operation,
     Id,
 }
 /// The selected issue operation returned by the operation
 /// selection widget.
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
 pub enum IssueOperation {
     Show,
     Delete,
     Edit,
     Comment,
 }
 impl Display for IssueOperation {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             IssueOperation::Show => {
                 write!(f, "show")
             }
             IssueOperation::Delete => {
                 write!(f, "delete")
             }
             IssueOperation::Edit => {
                 write!(f, "edit")
             }
             IssueOperation::Comment => {
                 write!(f, "comment")
             }
         }
     }
 }
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum ListCid {
     Header,
     PatchBrowser,
     Context,
     Shortcuts,
 }
 /// All component ids known to this application.
 #[derive(Debug, Default, Eq, PartialEq, Clone, Hash)]
 pub enum Cid {
     List(ListCid),
     #[default]
     GlobalListener,
 }
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum Message {
     #[default]
     Tick,
     Quit(Option<SelectionExit>),
     Batch(Vec<Message>),
 }
 pub struct App {
     context: Context,
     pages: PageStack<Cid, Message>,
     theme: Theme,
     quit: bool,
     mode: Mode,
     filter: Filter,
     output: Option<SelectionExit>,
 }
 /// Creates a new application using a tui-realm-application, mounts all
 /// components and sets focus to a default one.
 impl App {
     pub fn new(context: Context, mode: Mode, filter: Filter) -> Self {
         Self {
             context,
             pages: PageStack::default(),
             theme: Theme::default(),
             quit: false,
             mode,
             filter,
             output: None,
         }
     }
     fn view_list(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
     ) -> Result<()> {
         let home = Box::new(ListView::new(self.mode.clone(), self.filter.clone()));
         self.pages.push(home, app, &self.context, theme)?;
         Ok(())
     }
     fn process(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         message: Message,
     ) -> Result<Option<Message>> {
         let theme = Theme::default();
         match message {
             Message::Batch(messages) => {
                 let mut results = vec![];
                 for message in messages {
                     if let Some(result) = self.process(app, message)? {
                         results.push(result);
                     }
                 }
                 match results.len() {
 => Ok(None),
 => Ok(Some(results[0].to_owned())),
                     _ => Ok(Some(Message::Batch(results))),
                 }
             }
             Message::Quit(output) => {
                 self.quit = true;
                 self.output = output;
                 Ok(None)
             }
             _ => self
                 .pages
                 .peek_mut()?
                 .update(app, &self.context, &theme, message),
         }
     }
 }
 impl Tui<Cid, Message, SelectionExit> for App {
     fn init(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         self.view_list(app, &self.theme.clone())?;
         // Add global key listener and subscribe to key events
         let global = tui::ui::global_listener().to_boxed();
         app.mount(
             Cid::GlobalListener,
             global,
             vec![Sub::new(
                 subscription::quit_clause(Key::Char('q')),
                 SubClause::Always,
             )],
         )?;
         Ok(())
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         if let Ok(page) = self.pages.peek_mut() {
             page.view(app, frame);
         }
     }
     fn update(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<bool> {
         match app.tick(PollStrategy::Once) {
             Ok(messages) if !messages.is_empty() => {
                 for message in messages {
                     let mut msg = Some(message);
                     while msg.is_some() {
                         msg = self.process(app, msg.unwrap())?;
                     }
                 }
                 Ok(true)
             }
             _ => Ok(false),
         }
     }
     fn exit(&self) -> Option<Exit<SelectionExit>> {
         if self.quit {
             return Some(Exit {
                 value: self.output.clone(),
             });
         }
         None
     }
 }

deleted bin/commands/issue/select/event.rs

@@ -1,177 +0,0 @@

 use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection};
 use tuirealm::event::{Event, Key, KeyEvent};
 use tuirealm::{MockComponent, NoUserEvent};
 use radicle_tui as tui;
 use tui::ui::state::ItemState;
 use tui::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer};
 use tui::ui::widget::context::{ContextBar, Shortcuts};
 use tui::ui::widget::list::PropertyList;
 use tui::ui::widget::Widget;
 use tui::{Id, SelectionExit};
 use super::ui::{IdSelect, OperationSelect};
 use super::{IssueOperation, Message};
 /// Since the framework does not know the type of messages that are being
 /// passed around in the app, the following handlers need to be implemented for
 /// each component used.
 ///
 /// TODO: should handle `Event::WindowResize`, which is not emitted by `termion`.
 impl tuirealm::Component<Message, NoUserEvent> for Widget<GlobalListener> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent {
                 code: Key::Char('q'),
                 ..
             }) => Some(Message::Quit(None)),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<IdSelect> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         let mut submit = || -> Option<radicle::cob::patch::PatchId> {
             match self.perform(Cmd::Submit) {
                 CmdResult::Submit(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(item.id().to_owned())
                 }
                 _ => None,
             }
         };
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => submit().map(|id| {
                 let output = SelectionExit::default().with_id(Id::Object(id));
                 Message::Quit(Some(output))
             }),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<OperationSelect> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         let mut submit = || -> Option<radicle::cob::patch::PatchId> {
             match self.perform(Cmd::Submit) {
                 CmdResult::Submit(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(item.id().to_owned())
                 }
                 _ => None,
             }
         };
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(IssueOperation::Show.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('d'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(IssueOperation::Delete.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('e'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(IssueOperation::Edit.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('m'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(IssueOperation::Comment.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<AppHeader> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<LabeledContainer> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<PropertyList> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ContextBar> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Shortcuts> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }

deleted bin/commands/issue/select/page.rs

@@ -1,177 +0,0 @@

 use std::collections::HashMap;
 use anyhow::Result;
 use tui::ui::state::ItemState;
 use tuirealm::{AttrValue, Attribute, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::cob::issue::Filter;
 use tui::context::Context;
 use tui::ui::theme::Theme;
 use tui::ui::widget::context::{Progress, Shortcuts};
 use tui::ui::widget::Widget;
 use tui::ui::{layout, subscription};
 use tui::ViewPage;
 use super::super::common;
 use super::{ui, Application, Cid, ListCid, Message, Mode};
 ///
 /// Home
 ///
 pub struct ListView {
     active_component: ListCid,
     subject: Mode,
     filter: Filter,
     shortcuts: HashMap<ListCid, Widget<Shortcuts>>,
 }
 impl ListView {
     pub fn new(subject: Mode, filter: Filter) -> Self {
         Self {
             active_component: ListCid::PatchBrowser,
             subject,
             filter,
             shortcuts: HashMap::default(),
         }
     }
     fn update_context(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let state = app.state(&Cid::List(ListCid::PatchBrowser))?;
         let progress = match ItemState::try_from(state) {
             Ok(state) => Progress::Step(
                 state
                     .selected()
                     .map(|s| s.saturating_add(1))
                     .unwrap_or_default(),
                 state.len(),
             ),
             Err(_) => Progress::None,
         };
         let context = common::ui::browse_context(context, theme, self.filter.clone(), progress);
         app.remount(Cid::List(ListCid::Context), context.to_boxed(), vec![])?;
         Ok(())
     }
     fn update_shortcuts(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: ListCid,
     ) -> Result<()> {
         if let Some(shortcuts) = self.shortcuts.get(&cid) {
             app.remount(
                 Cid::List(ListCid::Shortcuts),
                 shortcuts.clone().to_boxed(),
                 vec![],
             )?;
         }
         Ok(())
     }
 }
 impl ViewPage<Cid, Message> for ListView {
     fn mount(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let navigation = ui::list_navigation(theme);
         let header = tui::ui::app_header(context, theme, Some(navigation)).to_boxed();
         app.remount(Cid::List(ListCid::Header), header, vec![])?;
         match self.subject {
             Mode::Id => {
                 let patch_browser =
                     ui::id_select(theme, context, self.filter.clone(), None).to_boxed();
                 self.shortcuts = patch_browser.as_ref().shortcuts();
                 app.remount(Cid::List(ListCid::PatchBrowser), patch_browser, vec![])?;
             }
             Mode::Operation => {
                 let patch_browser =
                     ui::operation_select(theme, context, self.filter.clone(), None).to_boxed();
                 self.shortcuts = patch_browser.as_ref().shortcuts();
                 app.remount(Cid::List(ListCid::PatchBrowser), patch_browser, vec![])?;
             }
         };
         app.active(&Cid::List(self.active_component.clone()))?;
         self.update_shortcuts(app, self.active_component.clone())?;
         self.update_context(app, context, theme)?;
         Ok(())
     }
     fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.umount(&Cid::List(ListCid::Header))?;
         app.umount(&Cid::List(ListCid::PatchBrowser))?;
         app.umount(&Cid::List(ListCid::Context))?;
         app.umount(&Cid::List(ListCid::Shortcuts))?;
         Ok(())
     }
     fn update(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         _message: Message,
     ) -> Result<Option<Message>> {
         self.update_context(app, context, theme)?;
         Ok(None)
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         let area = frame.size();
         let context_h = app
             .query(&Cid::List(ListCid::Context), Attribute::Height)
             .unwrap_or_default()
             .unwrap_or(AttrValue::Size(0))
             .unwrap_size();
         let shortcuts_h = 1u16;
         let layout = layout::default_page(area, context_h, shortcuts_h);
         app.view(
             &Cid::List(self.active_component.clone()),
             frame,
             layout.component,
         );
         app.view(&Cid::List(ListCid::Context), frame, layout.context);
         app.view(&Cid::List(ListCid::Shortcuts), frame, layout.shortcuts);
     }
     fn subscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.subscribe(
             &Cid::List(ListCid::Header),
             Sub::new(subscription::navigation_clause(), SubClause::Always),
         )?;
         Ok(())
     }
     fn unsubscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.unsubscribe(
             &Cid::List(ListCid::Header),
             subscription::navigation_clause(),
         )?;
         Ok(())
     }
 }

deleted bin/commands/issue/select/ui.rs

@@ -1,157 +0,0 @@

 use std::collections::HashMap;
 use radicle::issue::{Issue, IssueId};
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State};
 use radicle_tui as tui;
 use tui::cob::issue::Filter;
 use tui::context::Context;
 use tui::ui::cob::IssueItem;
 use tui::ui::theme::{style, Theme};
 use tui::ui::widget::container::Tabs;
 use tui::ui::widget::context::Shortcuts;
 use tui::ui::widget::label::{self};
 use tui::ui::widget::{Widget, WidgetComponent};
 use super::super::common;
 use super::ListCid;
 pub struct IdSelect {
     theme: Theme,
     browser: Widget<common::ui::IssueBrowser>,
 }
 impl IdSelect {
     pub fn new(theme: Theme, browser: Widget<common::ui::IssueBrowser>) -> Self {
         Self { theme, browser }
     }
     pub fn items(&self) -> &Vec<IssueItem> {
         self.browser.items()
     }
     pub fn shortcuts(&self) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::PatchBrowser,
             tui::ui::shortcuts(
                 &self.theme,
                 vec![
                     tui::ui::shortcut(&self.theme, "enter", "select"),
                     tui::ui::shortcut(&self.theme, "q", "quit"),
                 ],
             ),
         )]
         .iter()
         .cloned()
         .collect()
     }
 }
 impl WidgetComponent for IdSelect {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.browser.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.browser.view(frame, area);
     }
     fn state(&self) -> State {
         self.browser.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.browser.perform(cmd)
     }
 }
 pub struct OperationSelect {
     theme: Theme,
     browser: Widget<common::ui::IssueBrowser>,
 }
 impl OperationSelect {
     pub fn new(theme: Theme, browser: Widget<common::ui::IssueBrowser>) -> Self {
         Self { theme, browser }
     }
     pub fn items(&self) -> &Vec<IssueItem> {
         self.browser.items()
     }
     pub fn shortcuts(&self) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::PatchBrowser,
             tui::ui::shortcuts(
                 &self.theme,
                 vec![
                     tui::ui::shortcut(&self.theme, "enter", "show"),
                     tui::ui::shortcut(&self.theme, "m", "comment"),
                     tui::ui::shortcut(&self.theme, "e", "edit"),
                     tui::ui::shortcut(&self.theme, "d", "delete"),
                     tui::ui::shortcut(&self.theme, "q", "quit"),
                 ],
             ),
         )]
         .iter()
         .cloned()
         .collect()
     }
 }
 impl WidgetComponent for OperationSelect {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.browser.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.browser.view(frame, area);
     }
     fn state(&self) -> State {
         self.browser.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.browser.perform(cmd)
     }
 }
 pub fn list_navigation(theme: &Theme) -> Widget<Tabs> {
     tui::ui::tabs(
         theme,
         vec![label::reversable("Patches").style(style::cyan())],
     )
 }
 pub fn id_select(
     theme: &Theme,
     context: &Context,
     filter: Filter,
     selected: Option<(IssueId, Issue)>,
 ) -> Widget<IdSelect> {
     let browser = Widget::new(common::ui::IssueBrowser::new(
         theme, context, filter, selected,
     ));
     Widget::new(IdSelect::new(theme.clone(), browser))
 }
 pub fn operation_select(
     theme: &Theme,
     context: &Context,
     filter: Filter,
     selected: Option<(IssueId, Issue)>,
 ) -> Widget<OperationSelect> {
     let browser = Widget::new(common::ui::IssueBrowser::new(
         theme, context, filter, selected,
     ));
     Widget::new(OperationSelect::new(theme.clone(), browser))
 }

deleted bin/commands/issue/suite.rs

@@ -1,353 +0,0 @@

 #[path = "suite/event.rs"]
 mod event;
 #[path = "suite/page.rs"]
 mod page;
 #[path = "suite/ui.rs"]
 mod ui;
 use anyhow::Result;
 use radicle::cob::issue::IssueId;
 use tuirealm::application::PollStrategy;
 use tuirealm::event::Key;
 use tuirealm::{Application, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::cob;
 use tui::context::Context;
 use tui::ui::subscription;
 use tui::ui::theme::Theme;
 use tui::{Exit, PageStack, Tui};
 use page::{IssuePage, ListPage};
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum ListCid {
     Header,
     IssueBrowser,
     Context,
     Shortcuts,
 }
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum IssueCid {
     Header,
     List,
     Details,
     Context,
     Form,
     Shortcuts,
 }
 /// All component ids known to this application.
 #[derive(Debug, Default, Eq, PartialEq, Clone, Hash)]
 pub enum Cid {
     List(ListCid),
     Issue(IssueCid),
     #[default]
     GlobalListener,
     Popup,
 }
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IssueCobMessage {
     Create {
         title: String,
         tags: String,
         assignees: String,
         description: String,
     },
 }
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IssueMessage {
     Show(Option<IssueId>),
     Changed(IssueId),
     Focus(IssueCid),
     Created(IssueId),
     Cob(IssueCobMessage),
     Reload(Option<IssueId>),
     OpenForm,
     HideForm,
     Leave(Option<IssueId>),
 }
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum PopupMessage {
     Info(String),
     Warning(String),
     Error(String),
     Hide,
 }
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub enum Message {
     Issue(IssueMessage),
     NavigationChanged(u16),
     FormSubmitted(String),
     Popup(PopupMessage),
     #[default]
     Tick,
     Quit,
     Batch(Vec<Message>),
 }
 #[allow(dead_code)]
 pub struct App {
     context: Context,
     pages: PageStack<Cid, Message>,
     theme: Theme,
     quit: bool,
 }
 /// Creates a new application using a tui-realm-application, mounts all
 /// components and sets focus to a default one.
 #[allow(dead_code)]
 impl App {
     pub fn new(context: Context) -> Self {
         Self {
             context,
             pages: PageStack::default(),
             theme: Theme::default(),
             quit: false,
         }
     }
     fn view_list(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
     ) -> Result<()> {
         let list = Box::new(ListPage::new(theme.clone()));
         self.pages.push(list, app, &self.context, theme)?;
         Ok(())
     }
     fn view_issue(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         id: Option<IssueId>,
         theme: &Theme,
     ) -> Result<()> {
         let repo = self.context.repository();
         match id {
             Some(id) => {
                 if let Some(issue) = cob::issue::find(repo, &id)? {
                     let view = Box::new(IssuePage::new(&self.context, theme, Some((id, issue))));
                     self.pages.push(view, app, &self.context, theme)?;
                     Ok(())
                 } else {
                     Err(anyhow::anyhow!(
                         "Could not mount 'page::IssueView'. Issue not found."
                     ))
                 }
             }
             None => {
                 let view = Box::new(IssuePage::new(&self.context, theme, None));
                 self.pages.push(view, app, &self.context, theme)?;
                 Ok(())
             }
         }
     }
     fn process(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         message: Message,
     ) -> Result<Option<Message>> {
         let theme = Theme::default();
         match message {
             Message::Batch(messages) => {
                 let mut results = vec![];
                 for message in messages {
                     if let Some(result) = self.process(app, message)? {
                         results.push(result);
                     }
                 }
                 match results.len() {
 => Ok(None),
 => Ok(Some(results[0].to_owned())),
                     _ => Ok(Some(Message::Batch(results))),
                 }
             }
             Message::Issue(IssueMessage::Cob(IssueCobMessage::Create {
                 title,
                 tags,
                 assignees,
                 description,
             })) => match self.create_issue(title, description, tags, assignees) {
                 Ok(id) => {
                     self.context.reload_issues();
                     Ok(Some(Message::Batch(vec![
                         Message::Issue(IssueMessage::HideForm),
                         Message::Issue(IssueMessage::Created(id)),
                     ])))
                 }
                 Err(err) => {
                     let error = format!("{:?}", err);
                     self.show_error_popup(app, &theme, &error)?;
                     Ok(None)
                 }
             },
             Message::Issue(IssueMessage::Show(id)) => {
                 self.view_issue(app, id, &theme)?;
                 Ok(None)
             }
             Message::Issue(IssueMessage::Leave(id)) => {
                 self.pages.pop(app)?;
                 Ok(Some(Message::Issue(IssueMessage::Reload(id))))
             }
             Message::Popup(PopupMessage::Info(info)) => {
                 self.show_info_popup(app, &theme, &info)?;
                 Ok(None)
             }
             Message::Popup(PopupMessage::Warning(warning)) => {
                 self.show_warning_popup(app, &theme, &warning)?;
                 Ok(None)
             }
             Message::Popup(PopupMessage::Error(error)) => {
                 self.show_error_popup(app, &theme, &error)?;
                 Ok(None)
             }
             Message::Popup(PopupMessage::Hide) => {
                 self.hide_popup(app)?;
                 Ok(None)
             }
             Message::Quit => {
                 self.quit = true;
                 Ok(None)
             }
             _ => self
                 .pages
                 .peek_mut()?
                 .update(app, &self.context, &theme, message),
         }
     }
     fn show_info_popup(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
         message: &str,
     ) -> Result<()> {
         let popup = tui::ui::info(theme, message);
         app.remount(Cid::Popup, popup.to_boxed(), vec![])?;
         app.active(&Cid::Popup)?;
         Ok(())
     }
     fn show_warning_popup(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
         message: &str,
     ) -> Result<()> {
         let popup = tui::ui::warning(theme, message);
         app.remount(Cid::Popup, popup.to_boxed(), vec![])?;
         app.active(&Cid::Popup)?;
         Ok(())
     }
     fn show_error_popup(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
         message: &str,
     ) -> Result<()> {
         let popup = tui::ui::error(theme, message);
         app.remount(Cid::Popup, popup.to_boxed(), vec![])?;
         app.active(&Cid::Popup)?;
         Ok(())
     }
     fn hide_popup(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.blur()?;
         app.umount(&Cid::Popup)?;
         Ok(())
     }
     fn create_issue(
         &mut self,
         title: String,
         description: String,
         labels: String,
         assignees: String,
     ) -> Result<IssueId> {
         let repository = self.context.repository();
         let signer = self.context.signer().as_ref().unwrap();
         let labels = cob::parse_labels(labels)?;
         let assignees = cob::parse_assignees(assignees)?;
         cob::issue::create(
             repository,
             signer,
             title,
             description,
             labels.as_slice(),
             assignees.as_slice(),
         )
     }
 }
 impl Tui<Cid, Message, ()> for App {
     fn init(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         self.view_list(app, &self.theme.clone())?;
         // Add global key listener and subscribe to key events
         let global = tui::ui::global_listener().to_boxed();
         app.mount(
             Cid::GlobalListener,
             global,
             vec![Sub::new(
                 subscription::quit_clause(Key::Char('q')),
                 SubClause::Always,
             )],
         )?;
         Ok(())
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         if let Ok(page) = self.pages.peek_mut() {
             page.view(app, frame);
         }
         if app.mounted(&Cid::Popup) {
             app.view(&Cid::Popup, frame, frame.size());
         }
     }
     fn update(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<bool> {
         match app.tick(PollStrategy::Once) {
             Ok(messages) if !messages.is_empty() => {
                 for message in messages {
                     let mut msg = Some(message);
                     while msg.is_some() {
                         msg = self.process(app, msg.unwrap())?;
                     }
                 }
                 Ok(true)
             }
             _ => Ok(false),
         }
     }
     fn exit(&self) -> Option<Exit<()>> {
         if self.quit {
             return Some(Exit { value: None });
         }
         None
     }
 }

deleted bin/commands/issue/suite/event.rs

@@ -1,322 +0,0 @@

 use radicle::cob::issue::IssueId;
 use tui::ui::state::ItemState;
 use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection, Position};
 use tuirealm::event::{Event, Key, KeyEvent, KeyModifiers};
 use tuirealm::{MockComponent, NoUserEvent, State, StateValue};
 use radicle_tui as tui;
 use tui::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer, Popup};
 use tui::ui::widget::context::{ContextBar, Shortcuts};
 use tui::ui::widget::form::Form;
 use tui::ui::widget::list::PropertyList;
 use tui::ui::widget::Widget;
 use super::ui;
 use super::{IssueCid, IssueMessage, Message, PopupMessage};
 /// Since the framework does not know the type of messages that are being
 /// passed around in the app, the following handlers need to be implemented for
 /// each component used.
 ///
 /// TODO: should handle `Event::WindowResize`, which is not emitted by `termion`.
 impl tuirealm::Component<Message, NoUserEvent> for Widget<GlobalListener> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent {
                 code: Key::Char('q'),
                 ..
             }) => Some(Message::Quit),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<AppHeader> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Tab, .. }) => {
                 match self.perform(Cmd::Move(MoveDirection::Right)) {
                     CmdResult::Changed(State::One(StateValue::U16(index))) => {
                         Some(Message::NavigationChanged(index))
                     }
                     _ => None,
                 }
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ui::LargeList> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {
                 let selected = ItemState::try_from(self.state()).ok()?.selected()?;
                 let item = self.items().get(selected)?;
                 Some(Message::Issue(IssueMessage::Leave(Some(
                     item.id().to_owned(),
                 ))))
             }
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => match self.perform(Cmd::Move(MoveDirection::Up)) {
                 CmdResult::Changed(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(Message::Issue(IssueMessage::Changed(item.id().to_owned())))
                 }
                 _ => None,
             },
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => match self.perform(Cmd::Move(MoveDirection::Down)) {
                 CmdResult::Changed(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(Message::Issue(IssueMessage::Changed(item.id().to_owned())))
                 }
                 _ => None,
             },
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => Some(Message::Issue(IssueMessage::Focus(IssueCid::Details))),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('o'),
                 ..
             }) => Some(Message::Issue(IssueMessage::OpenForm)),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ui::IssueDetails> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Scroll(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Scroll(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {
                 Some(Message::Issue(IssueMessage::Focus(IssueCid::List)))
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Form> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent {
                 code: Key::Left, ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Left));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Right, ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Right));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent { code: Key::Up, .. }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Home, ..
             }) => {
                 self.perform(Cmd::GoTo(Position::Begin));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent { code: Key::End, .. }) => {
                 self.perform(Cmd::GoTo(Position::End));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Delete, ..
             }) => {
                 self.perform(Cmd::Cancel);
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Backspace,
                 ..
             }) => {
                 self.perform(Cmd::Delete);
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => {
                 self.perform(Cmd::Custom(Form::CMD_NEWLINE));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Char('s'),
                 modifiers: KeyModifiers::CONTROL,
             }) => {
                 self.perform(Cmd::Submit);
                 self.query(tuirealm::Attribute::Custom(Form::PROP_ID))
                     .map(|cid| Message::FormSubmitted(cid.unwrap_string()))
             }
             Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {
                 Some(Message::Issue(IssueMessage::HideForm))
             }
             Event::Keyboard(KeyEvent {
                 code: Key::BackTab, ..
             }) => {
                 self.perform(Cmd::Custom(Form::CMD_FOCUS_PREVIOUS));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent { code: Key::Tab, .. }) => {
                 self.perform(Cmd::Custom(Form::CMD_FOCUS_NEXT));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Char(ch),
                 modifiers: KeyModifiers::SHIFT,
             }) => {
                 self.perform(Cmd::Type(ch.to_ascii_uppercase()));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Char('v'),
                 modifiers: KeyModifiers::CONTROL,
             }) => {
                 self.perform(Cmd::Custom(Form::CMD_PASTE));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Char(ch),
                 ..
             }) => {
                 self.perform(Cmd::Type(ch));
                 Some(Message::Tick)
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ui::IssueBrowser> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         let mut submit = || -> Option<IssueId> {
             match self.perform(Cmd::Submit) {
                 CmdResult::Submit(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(item.id().to_owned())
                 }
                 _ => None,
             }
         };
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Char('o'),
                 ..
             }) => {
                 let id = submit();
                 Some(Message::Batch(vec![
                     Message::Issue(IssueMessage::Show(id)),
                     Message::Issue(IssueMessage::OpenForm),
                 ]))
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => {
                 let id = submit();
                 if id.is_some() {
                     Some(Message::Issue(IssueMessage::Show(id)))
                 } else {
                     None
                 }
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Popup> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {
                 Some(Message::Popup(PopupMessage::Hide))
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<LabeledContainer> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<PropertyList> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ContextBar> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Shortcuts> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }

deleted bin/commands/issue/suite/page.rs

@@ -1,569 +0,0 @@

 use std::collections::HashMap;
 use anyhow::Result;
 use radicle::cob::issue::{Issue, IssueId};
 use tui::ui::state::ItemState;
 use tuirealm::event::Key;
 use tuirealm::{AttrValue, Attribute, Frame, NoUserEvent, State, StateValue, Sub, SubClause};
 use radicle_tui as tui;
 use tui::cob;
 use tui::context::Context;
 use tui::ui::layout;
 use tui::ui::theme::Theme;
 use tui::ui::widget::context::{Progress, Shortcuts};
 use tui::ui::widget::Widget;
 use tui::ViewPage;
 use super::{
     Application, Cid, IssueCid, IssueCobMessage, IssueMessage, ListCid, Message, PopupMessage,
 };
 use super::subscription;
 use super::ui;
 ///
 /// Home
 ///
 pub struct ListPage {
     active_component: ListCid,
     shortcuts: HashMap<ListCid, Widget<Shortcuts>>,
 }
 impl ListPage {
     pub fn new(theme: Theme) -> Self {
         let shortcuts = Self::build_shortcuts(&theme);
         Self {
             active_component: ListCid::IssueBrowser,
             shortcuts,
         }
     }
     fn activate(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: ListCid,
     ) -> Result<()> {
         self.active_component = cid;
         let cid = Cid::List(self.active_component.clone());
         app.active(&cid)?;
         app.attr(&cid, Attribute::Focus, AttrValue::Flag(true))?;
         Ok(())
     }
     fn build_shortcuts(theme: &Theme) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::IssueBrowser,
             tui::ui::shortcuts(
                 theme,
                 vec![
                     tui::ui::shortcut(theme, "tab", "section"),
                     tui::ui::shortcut(theme, "↑/↓", "navigate"),
                     tui::ui::shortcut(theme, "enter", "show"),
                     tui::ui::shortcut(theme, "o", "open"),
                     tui::ui::shortcut(theme, "q", "quit"),
                 ],
             ),
         )]
         .iter()
         .cloned()
         .collect()
     }
     fn update_context(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let state = app.state(&Cid::List(ListCid::IssueBrowser))?;
         let progress = match ItemState::try_from(state) {
             Ok(state) => Progress::Step(
                 state
                     .selected()
                     .map(|s| s.saturating_add(1))
                     .unwrap_or_default(),
                 state.len(),
             ),
             Err(_) => Progress::None,
         };
         let context = ui::browse_context(context, theme, progress);
         app.remount(Cid::List(ListCid::Context), context.to_boxed(), vec![])?;
         Ok(())
     }
     fn update_shortcuts(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: ListCid,
     ) -> Result<()> {
         if let Some(shortcuts) = self.shortcuts.get(&cid) {
             app.remount(
                 Cid::List(ListCid::Shortcuts),
                 shortcuts.clone().to_boxed(),
                 vec![],
             )?;
         }
         Ok(())
     }
 }
 impl ViewPage<Cid, Message> for ListPage {
     fn mount(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let navigation = ui::list_navigation(theme);
         let header = tui::ui::app_header(context, theme, Some(navigation)).to_boxed();
         let issue_browser = ui::issues(context, theme, None).to_boxed();
         app.remount(Cid::List(ListCid::Header), header, vec![])?;
         app.remount(Cid::List(ListCid::IssueBrowser), issue_browser, vec![])?;
         app.active(&Cid::List(self.active_component.clone()))?;
         self.update_shortcuts(app, self.active_component.clone())?;
         self.update_context(app, context, theme)?;
         Ok(())
     }
     fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.umount(&Cid::List(ListCid::Header))?;
         app.umount(&Cid::List(ListCid::IssueBrowser))?;
         app.umount(&Cid::List(ListCid::Context))?;
         app.umount(&Cid::List(ListCid::Shortcuts))?;
         Ok(())
     }
     fn update(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         message: Message,
     ) -> Result<Option<Message>> {
         if let Message::Issue(IssueMessage::Reload(id)) = message {
             let selected = match id {
                 Some(id) => cob::issue::find(context.repository(), &id)?.map(|issue| (id, issue)),
                 _ => None,
             };
             let issue_browser = ui::issues(context, theme, selected).to_boxed();
             app.remount(Cid::List(ListCid::IssueBrowser), issue_browser, vec![])?;
             self.activate(app, ListCid::IssueBrowser)?;
         }
         self.update_context(app, context, theme)?;
         Ok(None)
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         let area = frame.size();
         let context_h = app
             .query(&Cid::List(ListCid::Context), Attribute::Height)
             .unwrap_or_default()
             .unwrap_or(AttrValue::Size(0))
             .unwrap_size();
         let shortcuts_h = 1u16;
         let layout = layout::full_page(area, context_h, shortcuts_h);
         app.view(&Cid::List(ListCid::Header), frame, layout.navigation);
         app.view(
             &Cid::List(self.active_component.clone()),
             frame,
             layout.component,
         );
         app.view(&Cid::List(ListCid::Shortcuts), frame, layout.shortcuts);
     }
     fn subscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.subscribe(
             &Cid::List(ListCid::Header),
             Sub::new(subscription::navigation_clause(), SubClause::Always),
         )?;
         Ok(())
     }
     fn unsubscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.unsubscribe(
             &Cid::List(ListCid::Header),
             subscription::navigation_clause(),
         )?;
         Ok(())
     }
 }
 ///
 /// Issue detail page
 ///
 pub struct IssuePage {
     issue: Option<(IssueId, Issue)>,
     active_component: IssueCid,
     shortcuts: HashMap<IssueCid, Widget<Shortcuts>>,
 }
 impl IssuePage {
     pub fn new(_context: &Context, theme: &Theme, issue: Option<(IssueId, Issue)>) -> Self {
         let shortcuts = Self::build_shortcuts(theme);
         let active_component = IssueCid::List;
         Self {
             issue,
             active_component,
             shortcuts,
         }
     }
     fn activate(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: IssueCid,
     ) -> Result<()> {
         self.active_component = cid;
         let cid = Cid::Issue(self.active_component.clone());
         app.active(&cid)?;
         app.attr(&cid, Attribute::Focus, AttrValue::Flag(true))?;
         Ok(())
     }
     fn build_shortcuts(theme: &Theme) -> HashMap<IssueCid, Widget<Shortcuts>> {
         [
             (
                 IssueCid::List,
                 tui::ui::shortcuts(
                     theme,
                     vec![
                         tui::ui::shortcut(theme, "esc", "back"),
                         tui::ui::shortcut(theme, "↑/↓", "navigate"),
                         tui::ui::shortcut(theme, "enter", "show"),
                         tui::ui::shortcut(theme, "o", "open"),
                         tui::ui::shortcut(theme, "q", "quit"),
                     ],
                 ),
             ),
             (
                 IssueCid::Details,
                 tui::ui::shortcuts(
                     theme,
                     vec![
                         tui::ui::shortcut(theme, "esc", "back"),
                         tui::ui::shortcut(theme, "↑/↓", "scroll"),
                         tui::ui::shortcut(theme, "q", "quit"),
                     ],
                 ),
             ),
             (
                 IssueCid::Form,
                 tui::ui::shortcuts(
                     theme,
                     vec![
                         tui::ui::shortcut(theme, "esc", "back"),
                         tui::ui::shortcut(theme, "shift + tab / tab", "navigate"),
                         tui::ui::shortcut(theme, "ctrl + s", "submit"),
                     ],
                 ),
             ),
         ]
         .iter()
         .cloned()
         .collect()
     }
     fn update_context(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         cid: IssueCid,
     ) -> Result<()> {
         let context = match cid {
             IssueCid::List => {
                 let state = app.state(&Cid::Issue(IssueCid::List))?;
                 let progress = match state {
                     State::Tup2((StateValue::Usize(step), StateValue::Usize(total))) => {
                         Progress::Step(step.saturating_add(1), total)
                     }
                     _ => Progress::None,
                 };
                 let context = ui::browse_context(context, theme, progress);
                 Some(context)
             }
             IssueCid::Details => {
                 let state = app.state(&Cid::Issue(IssueCid::Details))?;
                 let progress = match state {
                     State::One(StateValue::Usize(scroll)) => Progress::Percentage(scroll),
                     _ => Progress::None,
                 };
                 let context = ui::description_context(context, theme, progress);
                 Some(context)
             }
             IssueCid::Form => {
                 let context = ui::form_context(context, theme, Progress::None);
                 Some(context)
             }
             _ => None,
         };
         if let Some(context) = context {
             app.remount(Cid::Issue(IssueCid::Context), context.to_boxed(), vec![])?;
         }
         Ok(())
     }
     fn update_shortcuts(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: IssueCid,
     ) -> Result<()> {
         if let Some(shortcuts) = self.shortcuts.get(&cid) {
             app.remount(
                 Cid::Issue(IssueCid::Shortcuts),
                 shortcuts.clone().to_boxed(),
                 vec![],
             )?;
         }
         Ok(())
     }
 }
 impl ViewPage<Cid, Message> for IssuePage {
     fn mount(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let navigation = ui::list_navigation(theme);
         let header = tui::ui::app_header(context, theme, Some(navigation)).to_boxed();
         let list = ui::list(context, theme, self.issue.clone()).to_boxed();
         app.remount(Cid::Issue(IssueCid::Header), header, vec![])?;
         app.remount(Cid::Issue(IssueCid::List), list, vec![])?;
         if let Some((id, issue)) = &self.issue {
             let comments = issue.comments().collect::<Vec<_>>();
             let details = ui::details(
                 context,
                 theme,
                 (*id, issue.clone()),
                 comments.first().copied(),
             )
             .to_boxed();
             app.remount(Cid::Issue(IssueCid::Details), details, vec![])?;
         }
         app.active(&Cid::Issue(self.active_component.clone()))?;
         self.update_shortcuts(app, self.active_component.clone())?;
         self.update_context(app, context, theme, self.active_component.clone())?;
         Ok(())
     }
     fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.umount(&Cid::Issue(IssueCid::Header))?;
         app.umount(&Cid::Issue(IssueCid::List))?;
         app.umount(&Cid::Issue(IssueCid::Context))?;
         app.umount(&Cid::Issue(IssueCid::Shortcuts))?;
         if app.mounted(&Cid::Issue(IssueCid::Details)) {
             app.umount(&Cid::Issue(IssueCid::Details))?;
         }
         if app.mounted(&Cid::Issue(IssueCid::Form)) {
             app.umount(&Cid::Issue(IssueCid::Form))?;
         }
         Ok(())
     }
     fn update(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         message: Message,
     ) -> Result<Option<Message>> {
         match message {
             Message::Issue(IssueMessage::Created(id)) => {
                 let repo = context.repository();
                 if let Some(issue) = cob::issue::find(repo, &id)? {
                     self.issue = Some((id, issue.clone()));
                     let list = ui::list(context, theme, self.issue.clone()).to_boxed();
                     let comments = issue.comments().collect::<Vec<_>>();
                     let details = ui::details(
                         context,
                         theme,
                         (id, issue.clone()),
                         comments.first().copied(),
                     )
                     .to_boxed();
                     app.remount(Cid::Issue(IssueCid::List), list, vec![])?;
                     app.remount(Cid::Issue(IssueCid::Details), details, vec![])?;
                 }
             }
             Message::Issue(IssueMessage::Changed(id)) => {
                 let repo = context.repository();
                 if let Some(issue) = cob::issue::find(repo, &id)? {
                     self.issue = Some((id, issue.clone()));
                     let comments = issue.comments().collect::<Vec<_>>();
                     let details = ui::details(
                         context,
                         theme,
                         (id, issue.clone()),
                         comments.first().copied(),
                     )
                     .to_boxed();
                     app.remount(Cid::Issue(IssueCid::Details), details, vec![])?;
                 }
             }
             Message::Issue(IssueMessage::Focus(cid)) => {
                 self.activate(app, cid)?;
                 self.update_shortcuts(app, self.active_component.clone())?;
             }
             Message::Issue(IssueMessage::OpenForm) => {
                 let new_form = ui::new_form(context, theme).to_boxed();
                 let list = ui::list(context, theme, None).to_boxed();
                 app.remount(Cid::Issue(IssueCid::List), list, vec![])?;
                 app.remount(Cid::Issue(IssueCid::Form), new_form, vec![])?;
                 app.active(&Cid::Issue(IssueCid::Form))?;
                 app.unsubscribe(
                     &Cid::GlobalListener,
                     subscription::quit_clause(Key::Char('q')),
                 )?;
                 return Ok(Some(Message::Issue(IssueMessage::Focus(IssueCid::Form))));
             }
             Message::Issue(IssueMessage::HideForm) => {
                 app.umount(&Cid::Issue(IssueCid::Form))?;
                 let list = ui::list(context, theme, self.issue.clone()).to_boxed();
                 app.remount(Cid::Issue(IssueCid::List), list, vec![])?;
                 app.subscribe(
                     &Cid::GlobalListener,
                     Sub::new(subscription::quit_clause(Key::Char('q')), SubClause::Always),
                 )?;
                 if self.issue.is_none() {
                     return Ok(Some(Message::Issue(IssueMessage::Leave(None))));
                 }
                 return Ok(Some(Message::Issue(IssueMessage::Focus(IssueCid::List))));
             }
             Message::FormSubmitted(id) => {
                 if id == ui::FORM_ID_EDIT {
                     let state = app.state(&Cid::Issue(IssueCid::Form))?;
                     if let State::Linked(mut states) = state {
                         let mut missing_values = vec![];
                         let title = match states.front() {
                             Some(State::One(StateValue::String(title))) if !title.is_empty() => {
                                 Some(title.clone())
                             }
                             _ => None,
                         };
                         states.pop_front();
                         let tags = match states.front() {
                             Some(State::One(StateValue::String(tags))) => Some(tags.clone()),
                             _ => Some(String::from("[]")),
                         };
                         states.pop_front();
                         let assignees = match states.front() {
                             Some(State::One(StateValue::String(assignees))) => {
                                 Some(assignees.clone())
                             }
                             _ => Some(String::from("[]")),
                         };
                         states.pop_front();
                         let description = match states.front() {
                             Some(State::One(StateValue::String(description)))
                                 if !description.is_empty() =>
                             {
                                 Some(description.clone())
                             }
                             _ => None,
                         };
                         states.pop_front();
                         if title.is_none() {
                             missing_values.push("title");
                         }
                         if description.is_none() {
                             missing_values.push("description");
                         }
                         // show error popup if missing.
                         if !missing_values.is_empty() {
                             let error = format!("Missing fields: {:?}", missing_values);
                             return Ok(Some(Message::Popup(PopupMessage::Error(error))));
                         } else {
                             return Ok(Some(Message::Issue(IssueMessage::Cob(
                                 IssueCobMessage::Create {
                                     title: title.unwrap(),
                                     tags: tags.unwrap(),
                                     assignees: assignees.unwrap(),
                                     description: description.unwrap(),
                                 },
                             ))));
                         }
                     }
                 }
             }
             _ => {}
         }
         self.update_context(app, context, theme, self.active_component.clone())?;
         Ok(None)
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         let area = frame.size();
         let shortcuts_h = 1u16;
         let layout = layout::issue_page(area, shortcuts_h);
         app.view(&Cid::Issue(IssueCid::Header), frame, layout.header);
         app.view(&Cid::Issue(IssueCid::List), frame, layout.left);
         if app.mounted(&Cid::Issue(IssueCid::Form)) {
             app.view(&Cid::Issue(IssueCid::Form), frame, layout.right);
         } else if app.mounted(&Cid::Issue(IssueCid::Details)) {
             app.view(&Cid::Issue(IssueCid::Details), frame, layout.right);
         }
         app.view(&Cid::Issue(IssueCid::Context), frame, layout.context);
         app.view(&Cid::Issue(IssueCid::Shortcuts), frame, layout.shortcuts);
     }
     fn subscribe(&self, _app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         Ok(())
     }
     fn unsubscribe(&self, _app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         Ok(())
     }
 }

deleted bin/commands/issue/suite/ui.rs

@@ -1,436 +0,0 @@

 use radicle::node::AliasStore;
 use radicle::cob::thread::Comment;
 use radicle::cob::thread::CommentId;
 use radicle::cob::issue::Issue;
 use radicle::cob::issue::IssueId;
 use tui::ui::theme::style;
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::{Constraint, Direction, Layout, Rect};
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State};
 use radicle_tui as tui;
 use tui::context::Context;
 use tui::ui::cob;
 use tui::ui::cob::IssueItem;
 use tui::ui::theme::Theme;
 use tui::ui::widget::{Widget, WidgetComponent};
 use tui::ui::widget::container::{Container, Tabs};
 use tui::ui::widget::context::{ContextBar, Progress};
 use tui::ui::widget::form::{Form, TextArea, TextField};
 use tui::ui::widget::label::{self, Textarea};
 use tui::ui::widget::list::{ColumnWidth, List, Property, Table};
 pub const FORM_ID_EDIT: &str = "edit-form";
 pub struct IssueBrowser {
     items: Vec<IssueItem>,
     table: Widget<Table<IssueItem, 7>>,
 }
 impl IssueBrowser {
     pub fn new(context: &Context, theme: &Theme, selected: Option<(IssueId, Issue)>) -> Self {
         let header = [
             label::header(" ● "),
             label::header("ID"),
             label::header("Title"),
             label::header("Author"),
             label::header("Tags"),
             label::header("Assignees"),
             label::header("Opened"),
         ];
         let widths = [
             ColumnWidth::Fixed(3),
             ColumnWidth::Fixed(7),
             ColumnWidth::Grow,
             ColumnWidth::Fixed(21),
             ColumnWidth::Fixed(25),
             ColumnWidth::Fixed(21),
             ColumnWidth::Fixed(18),
         ];
         let repo = context.repository();
         let mut items = vec![];
         let issues = context.issues().as_ref().unwrap();
         for (id, issue) in issues {
             if let Ok(item) = IssueItem::try_from((context.profile(), repo, *id, issue.clone())) {
                 items.push(item);
             }
         }
         items.sort_by(|a, b| b.timestamp().cmp(a.timestamp()));
         items.sort_by(|a, b| b.state().cmp(a.state()));
         let selected = match selected {
             Some((id, issue)) => Some(IssueItem::from((context.profile(), repo, id, issue))),
             _ => items.first().cloned(),
         };
         let table = Widget::new(Table::new(&items, selected, header, widths, theme.clone()));
         Self { items, table }
     }
     pub fn items(&self) -> &Vec<IssueItem> {
         &self.items
     }
 }
 impl WidgetComponent for IssueBrowser {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.table.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.table.view(frame, area);
     }
     fn state(&self) -> State {
         self.table.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.table.perform(cmd)
     }
 }
 pub struct LargeList {
     items: Vec<IssueItem>,
     list: Widget<Container>,
 }
 impl LargeList {
     pub fn new(context: &Context, theme: &Theme, selected: Option<(IssueId, Issue)>) -> Self {
         let repo = context.repository();
         let issues = context.issues().as_ref().unwrap();
         let mut items = issues
             .iter()
             .map(|(id, issue)| IssueItem::from((context.profile(), repo, *id, issue.clone())))
             .collect::<Vec<_>>();
         items.sort_by(|a, b| b.timestamp().cmp(a.timestamp()));
         items.sort_by(|a, b| b.state().cmp(a.state()));
         let selected =
             selected.map(|(id, issue)| IssueItem::from((context.profile(), repo, id, issue)));
         let list = Widget::new(List::new(&items, selected, theme.clone()));
         let container = tui::ui::container(theme, list.to_boxed());
         Self {
             items,
             list: container,
         }
     }
     pub fn items(&self) -> &Vec<IssueItem> {
         &self.items
     }
 }
 impl WidgetComponent for LargeList {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.list.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.list.view(frame, area);
     }
     fn state(&self) -> State {
         self.list.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.list.perform(cmd)
     }
 }
 pub struct IssueHeader {
     container: Widget<Container>,
 }
 impl IssueHeader {
     pub fn new(context: &Context, theme: &Theme, issue: (IssueId, Issue)) -> Self {
         let repo = context.repository();
         let (id, issue) = issue;
         let author = issue.author();
         let author = author.id();
         let alias = context.profile().aliases().alias(author);
         let by_you = *author == context.profile().did();
         let item = IssueItem::from((context.profile(), repo, id, issue.clone()));
         let title = Property::new(label::property("Title"), label::default(item.title()));
         let author = match alias {
             Some(_) => label::alias(&cob::format_author(issue.author().id(), &alias, by_you)),
             None => label::did(&cob::format_author(issue.author().id(), &alias, by_you)),
         };
         let author = Property::new(label::property("Author"), author);
         let issue_id = Property::new(
             label::property("Issue"),
             label::default(&id.to_string()).style(style::gray()),
         );
         let labels = Property::new(
             label::property("Labels"),
             label::labels(&cob::format_labels(item.labels())),
         );
         let assignees = Property::new(
             label::property("Assignees"),
             label::did(&cob::format_assignees(
                 &item
                     .assignees()
                     .iter()
                     .map(|item| (item.did(), item.alias(), item.is_you()))
                     .collect::<Vec<_>>(),
             )),
         );
         let state = Property::new(
             label::property("Status"),
             label::default(&item.state().to_string()),
         );
         let table = tui::ui::property_table(
             theme,
             vec![
                 Widget::new(title),
                 Widget::new(issue_id),
                 Widget::new(author),
                 Widget::new(labels),
                 Widget::new(assignees),
                 Widget::new(state),
             ],
         );
         let container = tui::ui::container(theme, table.to_boxed());
         Self { container }
     }
 }
 impl WidgetComponent for IssueHeader {
     fn view(&mut self, _properties: &Props, frame: &mut Frame, area: Rect) {
         self.container.view(frame, area);
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 pub struct IssueDetails {
     header: Widget<IssueHeader>,
     description: Widget<CommentBody>,
 }
 impl IssueDetails {
     pub fn new(
         context: &Context,
         theme: &Theme,
         issue: (IssueId, Issue),
         description: Option<(&CommentId, &Comment)>,
     ) -> Self {
         Self {
             header: header(context, theme, issue),
             description: self::description(context, theme, description),
         }
     }
 }
 impl WidgetComponent for IssueDetails {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         let layout = Layout::default()
             .direction(Direction::Vertical)
             .constraints([Constraint::Length(8), Constraint::Min(1)])
             .split(area);
         self.header.view(frame, layout[0]);
         self.description
             .attr(Attribute::Focus, AttrValue::Flag(focus));
         self.description.view(frame, layout[1]);
     }
     fn state(&self) -> State {
         self.description.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.description.perform(cmd)
     }
 }
 pub struct CommentBody {
     textarea: Widget<Container>,
 }
 impl CommentBody {
     pub fn new(_context: &Context, theme: &Theme, comment: Option<(&CommentId, &Comment)>) -> Self {
         let content = match comment {
             Some((_, comment)) => comment.body().to_string(),
             None => String::new(),
         };
         let textarea = Widget::new(Textarea::default())
             .content(AttrValue::String(content))
             .style(style::reset());
         let textarea = tui::ui::container(theme, textarea.to_boxed());
         Self { textarea }
     }
 }
 impl WidgetComponent for CommentBody {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.textarea.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.textarea.view(frame, area);
     }
     fn state(&self) -> State {
         self.textarea.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.textarea.perform(cmd)
     }
 }
 pub fn list_navigation(theme: &Theme) -> Widget<Tabs> {
     tui::ui::tabs(
         theme,
         vec![label::reversable("Issues").style(style::magenta())],
     )
 }
 pub fn list(
     context: &Context,
     theme: &Theme,
     issue: Option<(IssueId, Issue)>,
 ) -> Widget<LargeList> {
     let list = LargeList::new(context, theme, issue);
     Widget::new(list)
 }
 pub fn header(context: &Context, theme: &Theme, issue: (IssueId, Issue)) -> Widget<IssueHeader> {
     let header = IssueHeader::new(context, theme, issue);
     Widget::new(header)
 }
 pub fn description(
     context: &Context,
     theme: &Theme,
     comment: Option<(&CommentId, &Comment)>,
 ) -> Widget<CommentBody> {
     let body = CommentBody::new(context, theme, comment);
     Widget::new(body)
 }
 pub fn new_form(_context: &Context, theme: &Theme) -> Widget<Form> {
     use tuirealm::props::Layout;
     let title = Widget::new(TextField::new(theme.clone(), "Title")).to_boxed();
     let tags = Widget::new(TextField::new(theme.clone(), "Labels (bug, ...)")).to_boxed();
     let assignees = Widget::new(TextField::new(
         theme.clone(),
         "Assignees (z6MkvAdxCp1oLVVTsqYvev9YrhSN3gBQNUSM45hhy4pgkexk, ...)",
     ))
     .to_boxed();
     let description = Widget::new(TextArea::new(theme.clone(), "Description")).to_boxed();
     let inputs: Vec<Box<dyn MockComponent>> = vec![title, tags, assignees, description];
     let layout = Layout::default().constraints(
         [
             Constraint::Length(3),
             Constraint::Length(3),
             Constraint::Length(3),
             Constraint::Min(3),
         ]
         .as_ref(),
     );
     Widget::new(Form::new(theme.clone(), inputs))
         .custom(Form::PROP_ID, AttrValue::String(String::from(FORM_ID_EDIT)))
         .layout(layout)
 }
 pub fn details(
     context: &Context,
     theme: &Theme,
     issue: (IssueId, Issue),
     comment: Option<(&CommentId, &Comment)>,
 ) -> Widget<IssueDetails> {
     let discussion = IssueDetails::new(context, theme, issue, comment);
     Widget::new(discussion)
 }
 pub fn browse_context(context: &Context, theme: &Theme, progress: Progress) -> Widget<ContextBar> {
     use radicle::cob::issue::State;
     let issues = context.issues().as_ref().unwrap();
     let open = issues
         .iter()
         .filter(|issue| *issue.1.state() == State::Open)
         .collect::<Vec<_>>()
         .len();
     let closed = issues
         .iter()
         .filter(|issue| *issue.1.state() != State::Open)
         .collect::<Vec<_>>()
         .len();
     tui::ui::widget::context::bar(
         theme,
         "Browse",
         "",
         "",
         &format!("{open} open | {closed} closed"),
         &progress.to_string(),
     )
 }
 pub fn description_context(
     _context: &Context,
     theme: &Theme,
     progress: Progress,
 ) -> Widget<ContextBar> {
     tui::ui::widget::context::bar(theme, "Show", "", "", "", &progress.to_string())
 }
 pub fn form_context(_context: &Context, theme: &Theme, progress: Progress) -> Widget<ContextBar> {
     tui::ui::widget::context::bar(theme, "Open", "", "", "", &progress.to_string())
         .custom(ContextBar::PROP_EDIT_MODE, AttrValue::Flag(true))
 }
 pub fn issues(
     context: &Context,
     theme: &Theme,
     selected: Option<(IssueId, Issue)>,
 ) -> Widget<IssueBrowser> {
     Widget::new(IssueBrowser::new(context, theme, selected))
 }

modified bin/commands/patch.rs

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

 #[cfg(feature = "realm")]
 #[path = "patch/realm.rs"]
 mod realm;
 #[path = "patch/common.rs"]
 mod common;
 #[path = "patch/select.rs"]
 mod select;
 #[path = "patch/suite.rs"]
 mod suite;
 use std::ffi::OsString;

@@ -11,13 +11,11 @@ use anyhow::anyhow;

 use radicle_tui as tui;
 use tui::cob::patch::{self, State};
 use tui::{context, log, Window};
 use tui::common::cob::patch::{self, State};
 use crate::terminal;
 use crate::terminal::args::{Args, Error, Help};
 pub const FPS: u64 = 60;
 pub const HELP: Help = Help {
     name: "patch",
     description: "Terminal interfaces for patches",

@@ -64,7 +62,7 @@ pub enum OperationName {

 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct SelectOptions {
     mode: select::Mode,
     mode: common::Mode,
     filter: patch::Filter,
 }

@@ -88,8 +86,8 @@ impl Args for Options {

                     let val = val.to_str().unwrap_or_default();
                     select_opts.mode = match val {
                         "operation" => select::Mode::Operation,
                         "id" => select::Mode::Id,
                         "operation" => common::Mode::Operation,
                         "id" => common::Mode::Id,
                         unknown => anyhow::bail!("unknown mode '{}'", unknown),
                     };
                 }

@@ -132,7 +130,13 @@ impl Args for Options {

     }
 }
 #[cfg(feature = "realm")]
 pub fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()> {
     use tui::common::context;
     use tui::common::log;
     use tui::realm::Window;
     pub const FPS: u64 = 60;
     let (_, id) = radicle::rad::cwd()
         .map_err(|_| anyhow!("this command must be run in the context of a project"))?;

@@ -143,7 +147,7 @@ pub fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()>

             log::enable(context.profile(), "patch", "select")?;
             let mut app = select::App::new(context, opts.mode.clone(), opts.filter.clone());
             let mut app = realm::select::App::new(context, opts.mode.clone(), opts.filter.clone());
             let output = Window::default().run(&mut app, 1000 / FPS)?;
             let output = output

@@ -156,3 +160,12 @@ pub fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()>

     Ok(())
 }
 #[cfg(feature = "flux")]
 pub fn run(options: Options, _ctx: impl terminal::Context) -> anyhow::Result<()> {
     match options.op {
         Operation::Select { opts: _ } => {
             anyhow::bail!("operation not yet implemented with flux")
         }
     }
 }

modified bin/commands/patch/common.rs

@@ -1,2 +1,10 @@

 #[path = "common/ui.rs"]
 pub mod ui;
 /// The application's mode. It tells the application
 /// which widgets to render and which output to produce.
 ///
 /// Depends on CLI arguments given by the user.
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum Mode {
     #[default]
     Operation,
     Id,
 }

deleted bin/commands/patch/common/ui.rs

@@ -1,180 +0,0 @@

 use radicle::cob::patch::{Patch, PatchId};
 use tui::ui::widget::context::{ContextBar, Progress};
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State};
 use radicle_tui as tui;
 use tui::cob::patch::Filter;
 use tui::context::Context;
 use tui::ui::cob::PatchItem;
 use tui::ui::theme::{style, Theme};
 use tui::ui::widget::{Widget, WidgetComponent};
 use tui::ui::widget::label::{self};
 use tui::ui::widget::list::{ColumnWidth, Table};
 pub struct PatchBrowser {
     items: Vec<PatchItem>,
     table: Widget<Table<PatchItem, 8>>,
 }
 impl PatchBrowser {
     pub fn new(
         theme: &Theme,
         context: &Context,
         filter: Filter,
         selected: Option<(PatchId, Patch)>,
     ) -> Self {
         let header = [
             label::header(" ● "),
             label::header("ID"),
             label::header("Title"),
             label::header("Author"),
             label::header("Head"),
             label::header("+"),
             label::header("-"),
             label::header("Updated"),
         ];
         let widths = [
             ColumnWidth::Fixed(3),
             ColumnWidth::Fixed(7),
             ColumnWidth::Grow,
             ColumnWidth::Fixed(21),
             ColumnWidth::Fixed(7),
             ColumnWidth::Fixed(4),
             ColumnWidth::Fixed(4),
             ColumnWidth::Fixed(18),
         ];
         let repo = context.repository();
         let patches = context
             .patches()
             .as_ref()
             .unwrap()
             .iter()
             .filter(|(_, patch)| filter.matches(context.profile(), patch));
         let mut items = vec![];
         for (id, patch) in patches {
             if let Ok(item) = PatchItem::try_from((context.profile(), repo, *id, patch.clone())) {
                 items.push(item);
             }
         }
         items.sort_by(|a, b| b.timestamp().cmp(a.timestamp()));
         items.sort_by(|a, b| a.state().cmp(b.state()));
         let selected = match selected {
             Some((id, patch)) => {
                 Some(PatchItem::try_from((context.profile(), repo, id, patch)).unwrap())
             }
             _ => items.first().cloned(),
         };
         let table = Widget::new(Table::new(&items, selected, header, widths, theme.clone()));
         Self { items, table }
     }
     pub fn items(&self) -> &Vec<PatchItem> {
         &self.items
     }
 }
 impl WidgetComponent for PatchBrowser {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.table.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.table.view(frame, area);
     }
     fn state(&self) -> State {
         self.table.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.table.perform(cmd)
     }
 }
 pub fn browse_context(
     context: &Context,
     _theme: &Theme,
     filter: Filter,
     progress: Progress,
 ) -> Widget<ContextBar> {
     use radicle::cob::patch::State;
     let mut draft = 0;
     let mut open = 0;
     let mut archived = 0;
     let mut merged = 0;
     let patches = context
         .patches()
         .as_ref()
         .unwrap()
         .iter()
         .filter(|(_, patch)| filter.matches(context.profile(), patch));
     for (_, patch) in patches {
         match patch.state() {
             State::Draft => draft += 1,
             State::Open { conflicts: _ } => open += 1,
             State::Archived => archived += 1,
             State::Merged {
                 commit: _,
                 revision: _,
             } => merged += 1,
         }
     }
     let context = label::reversable("/").style(style::magenta_reversed());
     let filter = label::default(&filter.to_string()).style(style::magenta_dim());
     let draft_n = label::default(&format!("{draft}")).style(style::gray_dim());
     let draft = label::default(" Draft");
     let open_n = label::default(&format!("{open}")).style(style::green());
     let open = label::default(" Open");
     let archived_n = label::default(&format!("{archived}")).style(style::yellow());
     let archived = label::default(" Archived");
     let merged_n = label::default(&format!("{merged}")).style(style::cyan());
     let merged = label::default(" Merged ");
     let progress = label::reversable(&progress.to_string()).style(style::magenta_reversed());
     let spacer = label::default("");
     let divider = label::default(" | ");
     let context_bar = ContextBar::new(
         label::group(&[context]),
         label::group(&[filter]),
         label::group(&[spacer]),
         label::group(&[
             draft_n,
             draft,
             divider.clone(),
             open_n,
             open,
             divider.clone(),
             archived_n,
             archived,
             divider,
             merged_n,
             merged,
         ]),
         label::group(&[progress]),
     );
     Widget::new(context_bar).height(1)
 }

added bin/commands/patch/realm.rs

@@ -0,0 +1,6 @@

 #[path = "realm/common.rs"]
 pub mod common;
 #[path = "realm/select.rs"]
 pub mod select;
 #[path = "realm/suite.rs"]
 pub mod suite;

added bin/commands/patch/realm/common.rs

@@ -0,0 +1,2 @@

+	`#[path = "common/ui.rs"]`
+	`pub mod ui;`

added bin/commands/patch/realm/common/ui.rs

@@ -0,0 +1,179 @@

 use radicle::cob::patch::{Patch, PatchId};
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State};
 use radicle_tui as tui;
 use tui::common::cob::patch::Filter;
 use tui::common::context::Context;
 use tui::realm::ui::cob::PatchItem;
 use tui::realm::ui::theme::{style, Theme};
 use tui::realm::ui::widget::context::{ContextBar, Progress};
 use tui::realm::ui::widget::label::{self};
 use tui::realm::ui::widget::list::{ColumnWidth, Table};
 use tui::realm::ui::widget::{Widget, WidgetComponent};
 pub struct PatchBrowser {
     items: Vec<PatchItem>,
     table: Widget<Table<PatchItem, 8>>,
 }
 impl PatchBrowser {
     pub fn new(
         theme: &Theme,
         context: &Context,
         filter: Filter,
         selected: Option<(PatchId, Patch)>,
     ) -> Self {
         let header = [
             label::header(" ● "),
             label::header("ID"),
             label::header("Title"),
             label::header("Author"),
             label::header("Head"),
             label::header("+"),
             label::header("-"),
             label::header("Updated"),
         ];
         let widths = [
             ColumnWidth::Fixed(3),
             ColumnWidth::Fixed(7),
             ColumnWidth::Grow,
             ColumnWidth::Fixed(21),
             ColumnWidth::Fixed(7),
             ColumnWidth::Fixed(4),
             ColumnWidth::Fixed(4),
             ColumnWidth::Fixed(18),
         ];
         let repo = context.repository();
         let patches = context
             .patches()
             .as_ref()
             .unwrap()
             .iter()
             .filter(|(_, patch)| filter.matches(context.profile(), patch));
         let mut items = vec![];
         for (id, patch) in patches {
             if let Ok(item) = PatchItem::try_from((context.profile(), repo, *id, patch.clone())) {
                 items.push(item);
             }
         }
         items.sort_by(|a, b| b.timestamp().cmp(a.timestamp()));
         items.sort_by(|a, b| a.state().cmp(b.state()));
         let selected = match selected {
             Some((id, patch)) => {
                 Some(PatchItem::try_from((context.profile(), repo, id, patch)).unwrap())
             }
             _ => items.first().cloned(),
         };
         let table = Widget::new(Table::new(&items, selected, header, widths, theme.clone()));
         Self { items, table }
     }
     pub fn items(&self) -> &Vec<PatchItem> {
         &self.items
     }
 }
 impl WidgetComponent for PatchBrowser {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.table.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.table.view(frame, area);
     }
     fn state(&self) -> State {
         self.table.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.table.perform(cmd)
     }
 }
 pub fn browse_context(
     context: &Context,
     _theme: &Theme,
     filter: Filter,
     progress: Progress,
 ) -> Widget<ContextBar> {
     use radicle::cob::patch::State;
     let mut draft = 0;
     let mut open = 0;
     let mut archived = 0;
     let mut merged = 0;
     let patches = context
         .patches()
         .as_ref()
         .unwrap()
         .iter()
         .filter(|(_, patch)| filter.matches(context.profile(), patch));
     for (_, patch) in patches {
         match patch.state() {
             State::Draft => draft += 1,
             State::Open { conflicts: _ } => open += 1,
             State::Archived => archived += 1,
             State::Merged {
                 commit: _,
                 revision: _,
             } => merged += 1,
         }
     }
     let context = label::reversable("/").style(style::magenta_reversed());
     let filter = label::default(&filter.to_string()).style(style::magenta_dim());
     let draft_n = label::default(&format!("{draft}")).style(style::gray_dim());
     let draft = label::default(" Draft");
     let open_n = label::default(&format!("{open}")).style(style::green());
     let open = label::default(" Open");
     let archived_n = label::default(&format!("{archived}")).style(style::yellow());
     let archived = label::default(" Archived");
     let merged_n = label::default(&format!("{merged}")).style(style::cyan());
     let merged = label::default(" Merged ");
     let progress = label::reversable(&progress.to_string()).style(style::magenta_reversed());
     let spacer = label::default("");
     let divider = label::default(" | ");
     let context_bar = ContextBar::new(
         label::group(&[context]),
         label::group(&[filter]),
         label::group(&[spacer]),
         label::group(&[
             draft_n,
             draft,
             divider.clone(),
             open_n,
             open,
             divider.clone(),
             archived_n,
             archived,
             divider,
             merged_n,
             merged,
         ]),
         label::group(&[progress]),
     );
     Widget::new(context_bar).height(1)
 }

added bin/commands/patch/realm/select.rs

@@ -0,0 +1,205 @@

 #[path = "select/event.rs"]
 mod event;
 #[path = "select/page.rs"]
 mod page;
 #[path = "select/ui.rs"]
 mod ui;
 use std::fmt::Display;
 use std::hash::Hash;
 use anyhow::Result;
 use serde::Serialize;
 use tuirealm::application::PollStrategy;
 use tuirealm::event::Key;
 use tuirealm::{Application, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::common::cob::patch::Filter;
 use tui::common::context::Context;
 use tui::realm::ui::subscription;
 use tui::realm::ui::theme::Theme;
 use tui::realm::{PageStack, Tui};
 use tui::{Exit, SelectionExit};
 use page::ListView;
 use super::super::common::Mode;
 /// The selected patch operation returned by the operation
 /// selection widget.
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
 pub enum PatchOperation {
     Show,
     Checkout,
     Delete,
     Edit,
     Comment,
 }
 impl Display for PatchOperation {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             PatchOperation::Show => {
                 write!(f, "show")
             }
             PatchOperation::Checkout => {
                 write!(f, "checkout")
             }
             PatchOperation::Delete => {
                 write!(f, "delete")
             }
             PatchOperation::Edit => {
                 write!(f, "edit")
             }
             PatchOperation::Comment => {
                 write!(f, "comment")
             }
         }
     }
 }
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum ListCid {
     Header,
     PatchBrowser,
     Context,
     Shortcuts,
 }
 /// All component ids known to this application.
 #[derive(Debug, Default, Eq, PartialEq, Clone, Hash)]
 pub enum Cid {
     List(ListCid),
     #[default]
     GlobalListener,
 }
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum Message {
     #[default]
     Tick,
     Quit(Option<SelectionExit>),
     Batch(Vec<Message>),
 }
 pub struct App {
     context: Context,
     pages: PageStack<Cid, Message>,
     theme: Theme,
     quit: bool,
     mode: Mode,
     filter: Filter,
     output: Option<SelectionExit>,
 }
 /// Creates a new application using a tui-realm-application, mounts all
 /// components and sets focus to a default one.
 impl App {
     pub fn new(context: Context, mode: Mode, filter: Filter) -> Self {
         Self {
             context,
             pages: PageStack::default(),
             theme: Theme::default(),
             quit: false,
             mode,
             filter,
             output: None,
         }
     }
     fn view_list(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
     ) -> Result<()> {
         let home = Box::new(ListView::new(self.mode.clone(), self.filter.clone()));
         self.pages.push(home, app, &self.context, theme)?;
         Ok(())
     }
     fn process(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         message: Message,
     ) -> Result<Option<Message>> {
         let theme = Theme::default();
         match message {
             Message::Batch(messages) => {
                 let mut results = vec![];
                 for message in messages {
                     if let Some(result) = self.process(app, message)? {
                         results.push(result);
                     }
                 }
                 match results.len() {
 => Ok(None),
 => Ok(Some(results[0].to_owned())),
                     _ => Ok(Some(Message::Batch(results))),
                 }
             }
             Message::Quit(output) => {
                 self.quit = true;
                 self.output = output;
                 Ok(None)
             }
             _ => self
                 .pages
                 .peek_mut()?
                 .update(app, &self.context, &theme, message),
         }
     }
 }
 impl Tui<Cid, Message, SelectionExit> for App {
     fn init(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         self.view_list(app, &self.theme.clone())?;
         // Add global key listener and subscribe to key events
         let global = tui::realm::ui::global_listener().to_boxed();
         app.mount(
             Cid::GlobalListener,
             global,
             vec![Sub::new(
                 subscription::quit_clause(Key::Char('q')),
                 SubClause::Always,
             )],
         )?;
         Ok(())
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         if let Ok(page) = self.pages.peek_mut() {
             page.view(app, frame);
         }
     }
     fn update(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<bool> {
         match app.tick(PollStrategy::Once) {
             Ok(messages) if !messages.is_empty() => {
                 for message in messages {
                     let mut msg = Some(message);
                     while msg.is_some() {
                         msg = self.process(app, msg.unwrap())?;
                     }
                 }
                 Ok(true)
             }
             _ => Ok(false),
         }
     }
     fn exit(&self) -> Option<Exit<SelectionExit>> {
         if self.quit {
             return Some(Exit {
                 value: self.output.clone(),
             });
         }
         None
     }
 }

added bin/commands/patch/realm/select/event.rs

@@ -0,0 +1,186 @@

 use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection};
 use tuirealm::event::{Event, Key, KeyEvent};
 use tuirealm::{MockComponent, NoUserEvent};
 use radicle_tui as tui;
 use tui::realm::ui::state::ItemState;
 use tui::realm::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer};
 use tui::realm::ui::widget::context::{ContextBar, Shortcuts};
 use tui::realm::ui::widget::list::PropertyList;
 use tui::realm::ui::widget::Widget;
 use tui::{Id, SelectionExit};
 use super::ui::{IdSelect, OperationSelect};
 use super::{Message, PatchOperation};
 /// Since the framework does not know the type of messages that are being
 /// passed around in the app, the following handlers need to be implemented for
 /// each component used.
 ///
 /// TODO: should handle `Event::WindowResize`, which is not emitted by `termion`.
 impl tuirealm::Component<Message, NoUserEvent> for Widget<GlobalListener> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent {
                 code: Key::Char('q'),
                 ..
             }) => Some(Message::Quit(None)),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<IdSelect> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         let mut submit = || -> Option<radicle::cob::patch::PatchId> {
             match self.perform(Cmd::Submit) {
                 CmdResult::Submit(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(item.id().to_owned())
                 }
                 _ => None,
             }
         };
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => submit().map(|id| {
                 let output = SelectionExit::default().with_id(Id::Object(id));
                 Message::Quit(Some(output))
             }),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<OperationSelect> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         let mut submit = || -> Option<radicle::cob::patch::PatchId> {
             match self.perform(Cmd::Submit) {
                 CmdResult::Submit(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(item.id().to_owned())
                 }
                 _ => None,
             }
         };
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(PatchOperation::Show.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('c'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(PatchOperation::Checkout.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('d'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(PatchOperation::Delete.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('e'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(PatchOperation::Edit.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('m'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(PatchOperation::Comment.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<AppHeader> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<LabeledContainer> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<PropertyList> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ContextBar> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Shortcuts> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }

added bin/commands/patch/realm/select/page.rs

@@ -0,0 +1,177 @@

 use std::collections::HashMap;
 use anyhow::Result;
 use tuirealm::{AttrValue, Attribute, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::common::cob::patch::Filter;
 use tui::common::context::Context;
 use tui::realm::ui::state::ItemState;
 use tui::realm::ui::theme::Theme;
 use tui::realm::ui::widget::context::{Progress, Shortcuts};
 use tui::realm::ui::widget::Widget;
 use tui::realm::ui::{layout, subscription};
 use tui::realm::ViewPage;
 use super::super::common;
 use super::{ui, Application, Cid, ListCid, Message, Mode};
 ///
 /// Home
 ///
 pub struct ListView {
     active_component: ListCid,
     subject: Mode,
     filter: Filter,
     shortcuts: HashMap<ListCid, Widget<Shortcuts>>,
 }
 impl ListView {
     pub fn new(subject: Mode, filter: Filter) -> Self {
         Self {
             active_component: ListCid::PatchBrowser,
             subject,
             filter,
             shortcuts: HashMap::default(),
         }
     }
     fn update_context(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let state = app.state(&Cid::List(ListCid::PatchBrowser))?;
         let progress = match ItemState::try_from(state) {
             Ok(state) => Progress::Step(
                 state
                     .selected()
                     .map(|s| s.saturating_add(1))
                     .unwrap_or_default(),
                 state.len(),
             ),
             Err(_) => Progress::None,
         };
         let context = common::ui::browse_context(context, theme, self.filter.clone(), progress);
         app.remount(Cid::List(ListCid::Context), context.to_boxed(), vec![])?;
         Ok(())
     }
     fn update_shortcuts(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: ListCid,
     ) -> Result<()> {
         if let Some(shortcuts) = self.shortcuts.get(&cid) {
             app.remount(
                 Cid::List(ListCid::Shortcuts),
                 shortcuts.clone().to_boxed(),
                 vec![],
             )?;
         }
         Ok(())
     }
 }
 impl ViewPage<Cid, Message> for ListView {
     fn mount(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let navigation = ui::list_navigation(theme);
         let header = tui::realm::ui::app_header(context, theme, Some(navigation)).to_boxed();
         app.remount(Cid::List(ListCid::Header), header, vec![])?;
         match self.subject {
             Mode::Id => {
                 let patch_browser =
                     ui::id_select(theme, context, self.filter.clone(), None).to_boxed();
                 self.shortcuts = patch_browser.as_ref().shortcuts();
                 app.remount(Cid::List(ListCid::PatchBrowser), patch_browser, vec![])?;
             }
             Mode::Operation => {
                 let patch_browser =
                     ui::operation_select(theme, context, self.filter.clone(), None).to_boxed();
                 self.shortcuts = patch_browser.as_ref().shortcuts();
                 app.remount(Cid::List(ListCid::PatchBrowser), patch_browser, vec![])?;
             }
         };
         app.active(&Cid::List(self.active_component.clone()))?;
         self.update_shortcuts(app, self.active_component.clone())?;
         self.update_context(app, context, theme)?;
         Ok(())
     }
     fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.umount(&Cid::List(ListCid::Header))?;
         app.umount(&Cid::List(ListCid::PatchBrowser))?;
         app.umount(&Cid::List(ListCid::Context))?;
         app.umount(&Cid::List(ListCid::Shortcuts))?;
         Ok(())
     }
     fn update(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         _message: Message,
     ) -> Result<Option<Message>> {
         self.update_context(app, context, theme)?;
         Ok(None)
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         let area = frame.size();
         let context_h = app
             .query(&Cid::List(ListCid::Context), Attribute::Height)
             .unwrap_or_default()
             .unwrap_or(AttrValue::Size(0))
             .unwrap_size();
         let shortcuts_h = 1u16;
         let layout = layout::default_page(area, context_h, shortcuts_h);
         app.view(
             &Cid::List(self.active_component.clone()),
             frame,
             layout.component,
         );
         app.view(&Cid::List(ListCid::Context), frame, layout.context);
         app.view(&Cid::List(ListCid::Shortcuts), frame, layout.shortcuts);
     }
     fn subscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.subscribe(
             &Cid::List(ListCid::Header),
             Sub::new(subscription::navigation_clause(), SubClause::Always),
         )?;
         Ok(())
     }
     fn unsubscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.unsubscribe(
             &Cid::List(ListCid::Header),
             subscription::navigation_clause(),
         )?;
         Ok(())
     }
 }

added bin/commands/patch/realm/select/ui.rs

@@ -0,0 +1,158 @@

 use std::collections::HashMap;
 use radicle::cob::patch::{Patch, PatchId};
 use radicle_tui as tui;
 use tui::common::cob::patch::Filter;
 use tui::common::context::Context;
 use tui::realm::ui::cob::PatchItem;
 use tui::realm::ui::theme::{style, Theme};
 use tui::realm::ui::widget::context::Shortcuts;
 use tui::realm::ui::widget::{Widget, WidgetComponent};
 use tui::realm::ui::widget::container::Tabs;
 use tui::realm::ui::widget::label::{self};
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State};
 use super::super::common;
 use super::ListCid;
 pub struct IdSelect {
     theme: Theme,
     browser: Widget<common::ui::PatchBrowser>,
 }
 impl IdSelect {
     pub fn new(theme: Theme, browser: Widget<common::ui::PatchBrowser>) -> Self {
         Self { theme, browser }
     }
     pub fn items(&self) -> &Vec<PatchItem> {
         self.browser.items()
     }
     pub fn shortcuts(&self) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::PatchBrowser,
             tui::realm::ui::shortcuts(
                 &self.theme,
                 vec![
                     tui::realm::ui::shortcut(&self.theme, "enter", "select"),
                     tui::realm::ui::shortcut(&self.theme, "q", "quit"),
                 ],
             ),
         )]
         .iter()
         .cloned()
         .collect()
     }
 }
 impl WidgetComponent for IdSelect {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.browser.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.browser.view(frame, area);
     }
     fn state(&self) -> State {
         self.browser.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.browser.perform(cmd)
     }
 }
 pub struct OperationSelect {
     theme: Theme,
     browser: Widget<common::ui::PatchBrowser>,
 }
 impl OperationSelect {
     pub fn new(theme: Theme, browser: Widget<common::ui::PatchBrowser>) -> Self {
         Self { theme, browser }
     }
     pub fn items(&self) -> &Vec<PatchItem> {
         self.browser.items()
     }
     pub fn shortcuts(&self) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::PatchBrowser,
             tui::realm::ui::shortcuts(
                 &self.theme,
                 vec![
                     tui::realm::ui::shortcut(&self.theme, "enter", "show"),
                     tui::realm::ui::shortcut(&self.theme, "c", "checkout"),
                     tui::realm::ui::shortcut(&self.theme, "m", "comment"),
                     tui::realm::ui::shortcut(&self.theme, "e", "edit"),
                     tui::realm::ui::shortcut(&self.theme, "d", "delete"),
                     tui::realm::ui::shortcut(&self.theme, "q", "quit"),
                 ],
             ),
         )]
         .iter()
         .cloned()
         .collect()
     }
 }
 impl WidgetComponent for OperationSelect {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.browser.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.browser.view(frame, area);
     }
     fn state(&self) -> State {
         self.browser.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.browser.perform(cmd)
     }
 }
 pub fn list_navigation(theme: &Theme) -> Widget<Tabs> {
     tui::realm::ui::tabs(
         theme,
         vec![label::reversable("Patches").style(style::cyan())],
     )
 }
 pub fn id_select(
     theme: &Theme,
     context: &Context,
     filter: Filter,
     selected: Option<(PatchId, Patch)>,
 ) -> Widget<IdSelect> {
     let browser = Widget::new(common::ui::PatchBrowser::new(
         theme, context, filter, selected,
     ));
     Widget::new(IdSelect::new(theme.clone(), browser))
 }
 pub fn operation_select(
     theme: &Theme,
     context: &Context,
     filter: Filter,
     selected: Option<(PatchId, Patch)>,
 ) -> Widget<OperationSelect> {
     let browser = Widget::new(common::ui::PatchBrowser::new(
         theme, context, filter, selected,
     ));
     Widget::new(OperationSelect::new(theme.clone(), browser))
 }

added bin/commands/patch/realm/suite.rs

@@ -0,0 +1,288 @@

 #[path = "suite/event.rs"]
 mod event;
 #[path = "suite/page.rs"]
 mod page;
 #[path = "suite/ui.rs"]
 mod ui;
 use std::hash::Hash;
 use anyhow::Result;
 use radicle::cob::patch::PatchId;
 use tuirealm::application::PollStrategy;
 use tuirealm::event::Key;
 use tuirealm::{Application, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::common::cob;
 use tui::common::cob::patch::Filter;
 use tui::common::context::Context;
 use tui::realm::ui::subscription;
 use tui::realm::ui::theme::Theme;
 use tui::realm::{PageStack, Tui};
 use tui::Exit;
 use page::{ListView, PatchView};
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum ListCid {
     Header,
     PatchBrowser,
     Context,
     Shortcuts,
 }
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum PatchCid {
     Header,
     Activity,
     Files,
     Context,
     Shortcuts,
 }
 /// All component ids known to this application.
 #[derive(Debug, Default, Eq, PartialEq, Clone, Hash)]
 pub enum Cid {
     List(ListCid),
     Patch(PatchCid),
     #[default]
     GlobalListener,
     Popup,
 }
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum PatchMessage {
     Show(PatchId),
     Leave,
 }
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum PopupMessage {
     Info(String),
     Warning(String),
     Error(String),
     Hide,
 }
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum Message {
     Patch(PatchMessage),
     NavigationChanged(u16),
     FormSubmitted(String),
     Popup(PopupMessage),
     #[default]
     Tick,
     Quit,
     Batch(Vec<Message>),
 }
 #[allow(dead_code)]
 pub struct App {
     context: Context,
     pages: PageStack<Cid, Message>,
     theme: Theme,
     filter: Filter,
     quit: bool,
 }
 /// Creates a new application using a tui-realm-application, mounts all
 /// components and sets focus to a default one.
 #[allow(dead_code)]
 impl App {
     pub fn new(context: Context, filter: Filter) -> Self {
         Self {
             context,
             pages: PageStack::default(),
             theme: Theme::default(),
             filter,
             quit: false,
         }
     }
     fn view_list(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
     ) -> Result<()> {
         let home = Box::new(ListView::new(theme.clone(), self.filter.clone()));
         self.pages.push(home, app, &self.context, theme)?;
         Ok(())
     }
     fn view_patch(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         id: PatchId,
         theme: &Theme,
     ) -> Result<()> {
         let repo = self.context.repository();
         if let Some(patch) = cob::patch::find(repo, &id)? {
             let view = Box::new(PatchView::new(theme.clone(), (id, patch)));
             self.pages.push(view, app, &self.context, theme)?;
             Ok(())
         } else {
             Err(anyhow::anyhow!(
                 "Could not mount 'page::PatchView'. Patch not found."
             ))
         }
     }
     fn process(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         message: Message,
     ) -> Result<Option<Message>> {
         let theme = Theme::default();
         match message {
             Message::Batch(messages) => {
                 let mut results = vec![];
                 for message in messages {
                     if let Some(result) = self.process(app, message)? {
                         results.push(result);
                     }
                 }
                 match results.len() {
 => Ok(None),
 => Ok(Some(results[0].to_owned())),
                     _ => Ok(Some(Message::Batch(results))),
                 }
             }
             Message::Patch(PatchMessage::Show(id)) => {
                 self.view_patch(app, id, &theme)?;
                 Ok(None)
             }
             Message::Patch(PatchMessage::Leave) => {
                 self.pages.pop(app)?;
                 Ok(None)
             }
             Message::Popup(PopupMessage::Info(info)) => {
                 self.show_info_popup(app, &theme, &info)?;
                 Ok(None)
             }
             Message::Popup(PopupMessage::Warning(warning)) => {
                 self.show_warning_popup(app, &theme, &warning)?;
                 Ok(None)
             }
             Message::Popup(PopupMessage::Error(error)) => {
                 self.show_error_popup(app, &theme, &error)?;
                 Ok(None)
             }
             Message::Popup(PopupMessage::Hide) => {
                 self.hide_popup(app)?;
                 Ok(None)
             }
             Message::Quit => {
                 self.quit = true;
                 Ok(None)
             }
             _ => self
                 .pages
                 .peek_mut()?
                 .update(app, &self.context, &theme, message),
         }
     }
     fn show_info_popup(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
         message: &str,
     ) -> Result<()> {
         let popup = tui::realm::ui::info(theme, message);
         app.remount(Cid::Popup, popup.to_boxed(), vec![])?;
         app.active(&Cid::Popup)?;
         Ok(())
     }
     fn show_warning_popup(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
         message: &str,
     ) -> Result<()> {
         let popup = tui::realm::ui::warning(theme, message);
         app.remount(Cid::Popup, popup.to_boxed(), vec![])?;
         app.active(&Cid::Popup)?;
         Ok(())
     }
     fn show_error_popup(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
         message: &str,
     ) -> Result<()> {
         let popup = tui::realm::ui::error(theme, message);
         app.remount(Cid::Popup, popup.to_boxed(), vec![])?;
         app.active(&Cid::Popup)?;
         Ok(())
     }
     fn hide_popup(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.blur()?;
         app.umount(&Cid::Popup)?;
         Ok(())
     }
 }
 impl Tui<Cid, Message, ()> for App {
     fn init(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         self.view_list(app, &self.theme.clone())?;
         // Add global key listener and subscribe to key events
         let global = tui::realm::ui::global_listener().to_boxed();
         app.mount(
             Cid::GlobalListener,
             global,
             vec![Sub::new(
                 subscription::quit_clause(Key::Char('q')),
                 SubClause::Always,
             )],
         )?;
         Ok(())
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         if let Ok(page) = self.pages.peek_mut() {
             page.view(app, frame);
         }
         if app.mounted(&Cid::Popup) {
             app.view(&Cid::Popup, frame, frame.size());
         }
     }
     fn update(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<bool> {
         match app.tick(PollStrategy::Once) {
             Ok(messages) if !messages.is_empty() => {
                 for message in messages {
                     let mut msg = Some(message);
                     while msg.is_some() {
                         msg = self.process(app, msg.unwrap())?;
                     }
                 }
                 Ok(true)
             }
             _ => Ok(false),
         }
     }
     fn exit(&self) -> Option<Exit<()>> {
         if self.quit {
             return Some(Exit { value: None });
         }
         None
     }
 }

added bin/commands/patch/realm/suite/event.rs

@@ -0,0 +1,140 @@

 use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection};
 use tuirealm::event::{Event, Key, KeyEvent};
 use tuirealm::{MockComponent, NoUserEvent, State, StateValue};
 use radicle_tui::realm::ui::state::ItemState;
 use radicle_tui::realm::ui::widget::container::{
     AppHeader, GlobalListener, LabeledContainer, Popup,
 };
 use radicle_tui::realm::ui::widget::context::{ContextBar, Shortcuts};
 use radicle_tui::realm::ui::widget::list::PropertyList;
 use radicle_tui::realm::ui::widget::Widget;
 use super::super::common;
 use super::{ui, Message, PatchMessage, PopupMessage};
 /// Since the framework does not know the type of messages that are being
 /// passed around in the app, the following handlers need to be implemented for
 /// each component used.
 ///
 /// TODO: should handle `Event::WindowResize`, which is not emitted by `termion`.
 impl tuirealm::Component<Message, NoUserEvent> for Widget<GlobalListener> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent {
                 code: Key::Char('q'),
                 ..
             }) => Some(Message::Quit),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<AppHeader> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Tab, .. }) => {
                 match self.perform(Cmd::Move(MoveDirection::Right)) {
                     CmdResult::Changed(State::One(StateValue::U16(index))) => {
                         Some(Message::NavigationChanged(index))
                     }
                     _ => None,
                 }
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<common::ui::PatchBrowser> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => match self.perform(Cmd::Submit) {
                 CmdResult::Submit(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(Message::Patch(PatchMessage::Show(item.id().to_owned())))
                 }
                 _ => None,
             },
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ui::Activity> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {
                 Some(Message::Patch(PatchMessage::Leave))
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ui::Files> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {
                 Some(Message::Patch(PatchMessage::Leave))
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Popup> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {
                 Some(Message::Popup(PopupMessage::Hide))
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<LabeledContainer> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<PropertyList> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ContextBar> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Shortcuts> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }

added bin/commands/patch/realm/suite/page.rs

@@ -0,0 +1,346 @@

 use std::collections::HashMap;
 use anyhow::Result;
 use radicle::cob::patch::{Patch, PatchId};
 use tuirealm::{AttrValue, Attribute, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::common::cob::patch::Filter;
 use tui::common::context::Context;
 use tui::realm::ui::state::ItemState;
 use tui::realm::ui::theme::Theme;
 use tui::realm::ui::widget::context::{Progress, Shortcuts};
 use tui::realm::ui::widget::Widget;
 use tui::realm::ui::{layout, subscription};
 use tui::realm::ViewPage;
 use super::{ui, Application, Cid, ListCid, Message, PatchCid};
 ///
 /// Home
 ///
 pub struct ListView {
     active_component: ListCid,
     shortcuts: HashMap<ListCid, Widget<Shortcuts>>,
     filter: Filter,
 }
 impl ListView {
     pub fn new(theme: Theme, filter: Filter) -> Self {
         let shortcuts = Self::build_shortcuts(&theme);
         Self {
             active_component: ListCid::PatchBrowser,
             shortcuts,
             filter,
         }
     }
     fn build_shortcuts(theme: &Theme) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::PatchBrowser,
             tui::realm::ui::shortcuts(
                 theme,
                 vec![
                     tui::realm::ui::shortcut(theme, "tab", "section"),
                     tui::realm::ui::shortcut(theme, "↑/↓", "navigate"),
                     tui::realm::ui::shortcut(theme, "enter", "show"),
                     tui::realm::ui::shortcut(theme, "q", "quit"),
                 ],
             ),
         )]
         .iter()
         .cloned()
         .collect()
     }
     fn update_context(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let state = app.state(&Cid::List(ListCid::PatchBrowser))?;
         let progress = match ItemState::try_from(state) {
             Ok(state) => Progress::Step(
                 state
                     .selected()
                     .map(|s| s.saturating_add(1))
                     .unwrap_or_default(),
                 state.len(),
             ),
             Err(_) => Progress::None,
         };
         let context = ui::browse_context(context, theme, progress);
         app.remount(Cid::List(ListCid::Context), context.to_boxed(), vec![])?;
         Ok(())
     }
     fn update_shortcuts(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: ListCid,
     ) -> Result<()> {
         if let Some(shortcuts) = self.shortcuts.get(&cid) {
             app.remount(
                 Cid::List(ListCid::Shortcuts),
                 shortcuts.clone().to_boxed(),
                 vec![],
             )?;
         }
         Ok(())
     }
 }
 impl ViewPage<Cid, Message> for ListView {
     fn mount(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let navigation = ui::list_navigation(theme);
         let header = tui::realm::ui::app_header(context, theme, Some(navigation)).to_boxed();
         let patch_browser = ui::patches(theme, context, self.filter.clone(), None).to_boxed();
         app.remount(Cid::List(ListCid::Header), header, vec![])?;
         app.remount(Cid::List(ListCid::PatchBrowser), patch_browser, vec![])?;
         app.active(&Cid::List(self.active_component.clone()))?;
         self.update_shortcuts(app, self.active_component.clone())?;
         self.update_context(app, context, theme)?;
         Ok(())
     }
     fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.umount(&Cid::List(ListCid::Header))?;
         app.umount(&Cid::List(ListCid::PatchBrowser))?;
         app.umount(&Cid::List(ListCid::Context))?;
         app.umount(&Cid::List(ListCid::Shortcuts))?;
         Ok(())
     }
     fn update(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         _message: Message,
     ) -> Result<Option<Message>> {
         self.update_context(app, context, theme)?;
         Ok(None)
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         let area = frame.size();
         let context_h = app
             .query(&Cid::List(ListCid::Context), Attribute::Height)
             .unwrap_or_default()
             .unwrap_or(AttrValue::Size(0))
             .unwrap_size();
         let shortcuts_h = 1u16;
         let layout = layout::full_page(area, context_h, shortcuts_h);
         app.view(&Cid::List(ListCid::Header), frame, layout.navigation);
         app.view(
             &Cid::List(self.active_component.clone()),
             frame,
             layout.component,
         );
         app.view(&Cid::List(ListCid::Context), frame, layout.context);
         app.view(&Cid::List(ListCid::Shortcuts), frame, layout.shortcuts);
     }
     fn subscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.subscribe(
             &Cid::List(ListCid::Header),
             Sub::new(subscription::navigation_clause(), SubClause::Always),
         )?;
         Ok(())
     }
     fn unsubscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.unsubscribe(
             &Cid::List(ListCid::Header),
             subscription::navigation_clause(),
         )?;
         Ok(())
     }
 }
 ///
 /// Patch detail page
 ///
 pub struct PatchView {
     active_component: PatchCid,
     patch: (PatchId, Patch),
     shortcuts: HashMap<PatchCid, Widget<Shortcuts>>,
 }
 impl PatchView {
     pub fn new(theme: Theme, patch: (PatchId, Patch)) -> Self {
         let shortcuts = Self::build_shortcuts(&theme);
         PatchView {
             active_component: PatchCid::Activity,
             patch,
             shortcuts,
         }
     }
     fn build_shortcuts(theme: &Theme) -> HashMap<PatchCid, Widget<Shortcuts>> {
         [
             (
                 PatchCid::Activity,
                 tui::realm::ui::shortcuts(
                     theme,
                     vec![
                         tui::realm::ui::shortcut(theme, "esc", "back"),
                         tui::realm::ui::shortcut(theme, "tab", "section"),
                         tui::realm::ui::shortcut(theme, "q", "quit"),
                     ],
                 ),
             ),
             (
                 PatchCid::Files,
                 tui::realm::ui::shortcuts(
                     theme,
                     vec![
                         tui::realm::ui::shortcut(theme, "esc", "back"),
                         tui::realm::ui::shortcut(theme, "tab", "section"),
                         tui::realm::ui::shortcut(theme, "q", "quit"),
                     ],
                 ),
             ),
         ]
         .iter()
         .cloned()
         .collect()
     }
     fn update_shortcuts(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: PatchCid,
     ) -> Result<()> {
         if let Some(shortcuts) = self.shortcuts.get(&cid) {
             app.remount(
                 Cid::Patch(PatchCid::Shortcuts),
                 shortcuts.clone().to_boxed(),
                 vec![],
             )?;
         }
         Ok(())
     }
 }
 impl ViewPage<Cid, Message> for PatchView {
     fn mount(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let navigation = ui::navigation(theme);
         let header = tui::realm::ui::app_header(context, theme, Some(navigation)).to_boxed();
         let activity = ui::activity(theme).to_boxed();
         let files = ui::files(theme).to_boxed();
         let context = ui::context(context, theme, self.patch.clone()).to_boxed();
         app.remount(Cid::Patch(PatchCid::Header), header, vec![])?;
         app.remount(Cid::Patch(PatchCid::Activity), activity, vec![])?;
         app.remount(Cid::Patch(PatchCid::Files), files, vec![])?;
         app.remount(Cid::Patch(PatchCid::Context), context, vec![])?;
         let active_component = Cid::Patch(self.active_component.clone());
         app.active(&active_component)?;
         self.update_shortcuts(app, self.active_component.clone())?;
         Ok(())
     }
     fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.umount(&Cid::Patch(PatchCid::Header))?;
         app.umount(&Cid::Patch(PatchCid::Activity))?;
         app.umount(&Cid::Patch(PatchCid::Files))?;
         app.umount(&Cid::Patch(PatchCid::Context))?;
         app.umount(&Cid::Patch(PatchCid::Shortcuts))?;
         Ok(())
     }
     fn update(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         _context: &Context,
         _theme: &Theme,
         message: Message,
     ) -> Result<Option<Message>> {
         if let Message::NavigationChanged(index) = message {
             self.active_component = PatchCid::from(index as usize);
             let active_component = Cid::Patch(self.active_component.clone());
             app.active(&active_component)?;
             self.update_shortcuts(app, self.active_component.clone())?;
         }
         Ok(None)
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         let area = frame.size();
         let context_h = app
             .query(&Cid::List(ListCid::Context), Attribute::Height)
             .unwrap_or_default()
             .unwrap_or(AttrValue::Size(0))
             .unwrap_size();
         let shortcuts_h = 1u16;
         let layout = layout::full_page(area, context_h, shortcuts_h);
         app.view(&Cid::Patch(PatchCid::Header), frame, layout.navigation);
         app.view(
             &Cid::Patch(self.active_component.clone()),
             frame,
             layout.component,
         );
         app.view(&Cid::Patch(PatchCid::Context), frame, layout.context);
         app.view(&Cid::Patch(PatchCid::Shortcuts), frame, layout.shortcuts);
     }
     fn subscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.subscribe(
             &Cid::Patch(PatchCid::Header),
             Sub::new(subscription::navigation_clause(), SubClause::Always),
         )?;
         Ok(())
     }
     fn unsubscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.unsubscribe(
             &Cid::Patch(PatchCid::Header),
             subscription::navigation_clause(),
         )?;
         Ok(())
     }
 }
 impl From<usize> for PatchCid {
     fn from(index: usize) -> Self {
         match index {
 => PatchCid::Activity,
 => PatchCid::Files,
             _ => PatchCid::Activity,
         }
     }
 }

added bin/commands/patch/realm/suite/ui.rs

@@ -0,0 +1,171 @@

 use radicle::cob::patch::{Patch, PatchId};
 use radicle::node::AliasStore;
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State};
 use radicle_tui as tui;
 use tui::common::cob::patch::Filter;
 use tui::common::context::Context;
 use tui::realm::ui::cob;
 use tui::realm::ui::layout;
 use tui::realm::ui::theme::{style, Theme};
 use tui::realm::ui::widget::{Widget, WidgetComponent};
 use tui::realm::ui::widget::container::Tabs;
 use tui::realm::ui::widget::context::{ContextBar, Progress};
 use tui::realm::ui::widget::label::{self, Label};
 use super::super::common;
 pub struct Activity {
     label: Widget<Label>,
 }
 impl Activity {
     pub fn new(label: Widget<Label>) -> Self {
         Self { label }
     }
 }
 impl WidgetComponent for Activity {
     fn view(&mut self, _properties: &Props, frame: &mut Frame, area: Rect) {
         let label_w = self
             .label
             .query(Attribute::Width)
             .unwrap_or(AttrValue::Size(1))
             .unwrap_size();
         self.label
             .view(frame, layout::centered_label(label_w, area));
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 pub struct Files {
     label: Widget<Label>,
 }
 impl Files {
     pub fn new(label: Widget<Label>) -> Self {
         Self { label }
     }
 }
 impl WidgetComponent for Files {
     fn view(&mut self, _properties: &Props, frame: &mut Frame, area: Rect) {
         let label_w = self
             .label
             .query(Attribute::Width)
             .unwrap_or(AttrValue::Size(1))
             .unwrap_size();
         self.label
             .view(frame, layout::centered_label(label_w, area));
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 pub fn list_navigation(theme: &Theme) -> Widget<Tabs> {
     tui::realm::ui::tabs(
         theme,
         vec![label::reversable("Patches").style(style::magenta())],
     )
 }
 pub fn navigation(theme: &Theme) -> Widget<Tabs> {
     tui::realm::ui::tabs(
         theme,
         vec![
             label::reversable("Activity").style(style::magenta()),
             label::reversable("Files").style(style::magenta()),
         ],
     )
 }
 pub fn patches(
     theme: &Theme,
     context: &Context,
     filter: Filter,
     selected: Option<(PatchId, Patch)>,
 ) -> Widget<common::ui::PatchBrowser> {
     Widget::new(common::ui::PatchBrowser::new(
         theme, context, filter, selected,
     ))
 }
 pub fn activity(_theme: &Theme) -> Widget<Activity> {
     let not_implemented = label::default("not implemented").style(style::reset());
     let activity = Activity::new(not_implemented);
     Widget::new(activity)
 }
 pub fn files(_theme: &Theme) -> Widget<Files> {
     let not_implemented = label::default("not implemented").style(style::reset());
     let files = Files::new(not_implemented);
     Widget::new(files)
 }
 pub fn context(context: &Context, theme: &Theme, patch: (PatchId, Patch)) -> Widget<ContextBar> {
     let (id, patch) = patch;
     let (_, rev) = patch.latest();
     let is_you = *patch.author().id() == context.profile().did();
     let id = cob::format::cob(&id);
     let title = patch.title();
     let author = patch.author().id();
     let alias = context.profile().aliases().alias(author);
     let author = cob::format_author(author, &alias, is_you);
     let comments = rev.discussion().len();
     tui::realm::ui::widget::context::bar(theme, "Patch", &id, title, &author, &comments.to_string())
 }
 pub fn browse_context(context: &Context, theme: &Theme, progress: Progress) -> Widget<ContextBar> {
     use radicle::cob::patch::State;
     let mut draft = 0;
     let mut open = 0;
     let mut archived = 0;
     let mut merged = 0;
     let patches = context.patches().as_ref().unwrap();
     for (_, patch) in patches {
         match patch.state() {
             State::Draft => draft += 1,
             State::Open { conflicts: _ } => open += 1,
             State::Archived => archived += 1,
             State::Merged {
                 commit: _,
                 revision: _,
             } => merged += 1,
         }
     }
     tui::realm::ui::widget::context::bar(
         theme,
         "Browse",
         "",
         "",
         &format!("{draft} draft | {open} open | {archived} archived | {merged} merged"),
         &progress.to_string(),
     )
 }

deleted bin/commands/patch/select.rs

@@ -1,212 +0,0 @@

 #[path = "select/event.rs"]
 mod event;
 #[path = "select/page.rs"]
 mod page;
 #[path = "select/ui.rs"]
 mod ui;
 use std::fmt::Display;
 use std::hash::Hash;
 use anyhow::Result;
 use serde::Serialize;
 use tuirealm::application::PollStrategy;
 use tuirealm::event::Key;
 use tuirealm::{Application, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::cob::patch::Filter;
 use tui::context::Context;
 use tui::ui::subscription;
 use tui::ui::theme::Theme;
 use tui::{Exit, PageStack, SelectionExit, Tui};
 use page::ListView;
 /// The application's mode. It tells the application
 /// which widgets to render and which output to produce.
 /// Depends on CLI arguments given by the user.
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum Mode {
     #[default]
     Operation,
     Id,
 }
 /// The selected patch operation returned by the operation
 /// selection widget.
 #[derive(Clone, Debug, Eq, PartialEq, Serialize)]
 pub enum PatchOperation {
     Show,
     Checkout,
     Delete,
     Edit,
     Comment,
 }
 impl Display for PatchOperation {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             PatchOperation::Show => {
                 write!(f, "show")
             }
             PatchOperation::Checkout => {
                 write!(f, "checkout")
             }
             PatchOperation::Delete => {
                 write!(f, "delete")
             }
             PatchOperation::Edit => {
                 write!(f, "edit")
             }
             PatchOperation::Comment => {
                 write!(f, "comment")
             }
         }
     }
 }
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum ListCid {
     Header,
     PatchBrowser,
     Context,
     Shortcuts,
 }
 /// All component ids known to this application.
 #[derive(Debug, Default, Eq, PartialEq, Clone, Hash)]
 pub enum Cid {
     List(ListCid),
     #[default]
     GlobalListener,
 }
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum Message {
     #[default]
     Tick,
     Quit(Option<SelectionExit>),
     Batch(Vec<Message>),
 }
 pub struct App {
     context: Context,
     pages: PageStack<Cid, Message>,
     theme: Theme,
     quit: bool,
     mode: Mode,
     filter: Filter,
     output: Option<SelectionExit>,
 }
 /// Creates a new application using a tui-realm-application, mounts all
 /// components and sets focus to a default one.
 impl App {
     pub fn new(context: Context, mode: Mode, filter: Filter) -> Self {
         Self {
             context,
             pages: PageStack::default(),
             theme: Theme::default(),
             quit: false,
             mode,
             filter,
             output: None,
         }
     }
     fn view_list(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
     ) -> Result<()> {
         let home = Box::new(ListView::new(self.mode.clone(), self.filter.clone()));
         self.pages.push(home, app, &self.context, theme)?;
         Ok(())
     }
     fn process(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         message: Message,
     ) -> Result<Option<Message>> {
         let theme = Theme::default();
         match message {
             Message::Batch(messages) => {
                 let mut results = vec![];
                 for message in messages {
                     if let Some(result) = self.process(app, message)? {
                         results.push(result);
                     }
                 }
                 match results.len() {
 => Ok(None),
 => Ok(Some(results[0].to_owned())),
                     _ => Ok(Some(Message::Batch(results))),
                 }
             }
             Message::Quit(output) => {
                 self.quit = true;
                 self.output = output;
                 Ok(None)
             }
             _ => self
                 .pages
                 .peek_mut()?
                 .update(app, &self.context, &theme, message),
         }
     }
 }
 impl Tui<Cid, Message, SelectionExit> for App {
     fn init(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         self.view_list(app, &self.theme.clone())?;
         // Add global key listener and subscribe to key events
         let global = tui::ui::global_listener().to_boxed();
         app.mount(
             Cid::GlobalListener,
             global,
             vec![Sub::new(
                 subscription::quit_clause(Key::Char('q')),
                 SubClause::Always,
             )],
         )?;
         Ok(())
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         if let Ok(page) = self.pages.peek_mut() {
             page.view(app, frame);
         }
     }
     fn update(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<bool> {
         match app.tick(PollStrategy::Once) {
             Ok(messages) if !messages.is_empty() => {
                 for message in messages {
                     let mut msg = Some(message);
                     while msg.is_some() {
                         msg = self.process(app, msg.unwrap())?;
                     }
                 }
                 Ok(true)
             }
             _ => Ok(false),
         }
     }
     fn exit(&self) -> Option<Exit<SelectionExit>> {
         if self.quit {
             return Some(Exit {
                 value: self.output.clone(),
             });
         }
         None
     }
 }

deleted bin/commands/patch/select/event.rs

@@ -1,186 +0,0 @@

 use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection};
 use tuirealm::event::{Event, Key, KeyEvent};
 use tuirealm::{MockComponent, NoUserEvent};
 use radicle_tui as tui;
 use tui::ui::state::ItemState;
 use tui::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer};
 use tui::ui::widget::context::{ContextBar, Shortcuts};
 use tui::ui::widget::list::PropertyList;
 use tui::ui::widget::Widget;
 use tui::{Id, SelectionExit};
 use super::ui::{IdSelect, OperationSelect};
 use super::{Message, PatchOperation};
 /// Since the framework does not know the type of messages that are being
 /// passed around in the app, the following handlers need to be implemented for
 /// each component used.
 ///
 /// TODO: should handle `Event::WindowResize`, which is not emitted by `termion`.
 impl tuirealm::Component<Message, NoUserEvent> for Widget<GlobalListener> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent {
                 code: Key::Char('q'),
                 ..
             }) => Some(Message::Quit(None)),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<IdSelect> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         let mut submit = || -> Option<radicle::cob::patch::PatchId> {
             match self.perform(Cmd::Submit) {
                 CmdResult::Submit(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(item.id().to_owned())
                 }
                 _ => None,
             }
         };
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => submit().map(|id| {
                 let output = SelectionExit::default().with_id(Id::Object(id));
                 Message::Quit(Some(output))
             }),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<OperationSelect> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         let mut submit = || -> Option<radicle::cob::patch::PatchId> {
             match self.perform(Cmd::Submit) {
                 CmdResult::Submit(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(item.id().to_owned())
                 }
                 _ => None,
             }
         };
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(PatchOperation::Show.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('c'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(PatchOperation::Checkout.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('d'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(PatchOperation::Delete.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('e'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(PatchOperation::Edit.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             Event::Keyboard(KeyEvent {
                 code: Key::Char('m'),
                 ..
             }) => submit().map(|id| {
                 let exit = SelectionExit::default()
                     .with_operation(PatchOperation::Comment.to_string())
                     .with_id(Id::Object(id));
                 Message::Quit(Some(exit))
             }),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<AppHeader> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<LabeledContainer> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<PropertyList> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ContextBar> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Shortcuts> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }

deleted bin/commands/patch/select/page.rs

@@ -1,177 +0,0 @@

 use std::collections::HashMap;
 use anyhow::Result;
 use tui::ui::state::ItemState;
 use tuirealm::{AttrValue, Attribute, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::cob::patch::Filter;
 use tui::context::Context;
 use tui::ui::theme::Theme;
 use tui::ui::widget::context::{Progress, Shortcuts};
 use tui::ui::widget::Widget;
 use tui::ui::{layout, subscription};
 use tui::ViewPage;
 use super::super::common;
 use super::{ui, Application, Cid, ListCid, Message, Mode};
 ///
 /// Home
 ///
 pub struct ListView {
     active_component: ListCid,
     subject: Mode,
     filter: Filter,
     shortcuts: HashMap<ListCid, Widget<Shortcuts>>,
 }
 impl ListView {
     pub fn new(subject: Mode, filter: Filter) -> Self {
         Self {
             active_component: ListCid::PatchBrowser,
             subject,
             filter,
             shortcuts: HashMap::default(),
         }
     }
     fn update_context(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let state = app.state(&Cid::List(ListCid::PatchBrowser))?;
         let progress = match ItemState::try_from(state) {
             Ok(state) => Progress::Step(
                 state
                     .selected()
                     .map(|s| s.saturating_add(1))
                     .unwrap_or_default(),
                 state.len(),
             ),
             Err(_) => Progress::None,
         };
         let context = common::ui::browse_context(context, theme, self.filter.clone(), progress);
         app.remount(Cid::List(ListCid::Context), context.to_boxed(), vec![])?;
         Ok(())
     }
     fn update_shortcuts(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: ListCid,
     ) -> Result<()> {
         if let Some(shortcuts) = self.shortcuts.get(&cid) {
             app.remount(
                 Cid::List(ListCid::Shortcuts),
                 shortcuts.clone().to_boxed(),
                 vec![],
             )?;
         }
         Ok(())
     }
 }
 impl ViewPage<Cid, Message> for ListView {
     fn mount(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let navigation = ui::list_navigation(theme);
         let header = tui::ui::app_header(context, theme, Some(navigation)).to_boxed();
         app.remount(Cid::List(ListCid::Header), header, vec![])?;
         match self.subject {
             Mode::Id => {
                 let patch_browser =
                     ui::id_select(theme, context, self.filter.clone(), None).to_boxed();
                 self.shortcuts = patch_browser.as_ref().shortcuts();
                 app.remount(Cid::List(ListCid::PatchBrowser), patch_browser, vec![])?;
             }
             Mode::Operation => {
                 let patch_browser =
                     ui::operation_select(theme, context, self.filter.clone(), None).to_boxed();
                 self.shortcuts = patch_browser.as_ref().shortcuts();
                 app.remount(Cid::List(ListCid::PatchBrowser), patch_browser, vec![])?;
             }
         };
         app.active(&Cid::List(self.active_component.clone()))?;
         self.update_shortcuts(app, self.active_component.clone())?;
         self.update_context(app, context, theme)?;
         Ok(())
     }
     fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.umount(&Cid::List(ListCid::Header))?;
         app.umount(&Cid::List(ListCid::PatchBrowser))?;
         app.umount(&Cid::List(ListCid::Context))?;
         app.umount(&Cid::List(ListCid::Shortcuts))?;
         Ok(())
     }
     fn update(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         _message: Message,
     ) -> Result<Option<Message>> {
         self.update_context(app, context, theme)?;
         Ok(None)
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         let area = frame.size();
         let context_h = app
             .query(&Cid::List(ListCid::Context), Attribute::Height)
             .unwrap_or_default()
             .unwrap_or(AttrValue::Size(0))
             .unwrap_size();
         let shortcuts_h = 1u16;
         let layout = layout::default_page(area, context_h, shortcuts_h);
         app.view(
             &Cid::List(self.active_component.clone()),
             frame,
             layout.component,
         );
         app.view(&Cid::List(ListCid::Context), frame, layout.context);
         app.view(&Cid::List(ListCid::Shortcuts), frame, layout.shortcuts);
     }
     fn subscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.subscribe(
             &Cid::List(ListCid::Header),
             Sub::new(subscription::navigation_clause(), SubClause::Always),
         )?;
         Ok(())
     }
     fn unsubscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.unsubscribe(
             &Cid::List(ListCid::Header),
             subscription::navigation_clause(),
         )?;
         Ok(())
     }
 }

deleted bin/commands/patch/select/ui.rs

@@ -1,158 +0,0 @@

 use std::collections::HashMap;
 use radicle::cob::patch::{Patch, PatchId};
 use radicle_tui as tui;
 use tui::cob::patch::Filter;
 use tui::context::Context;
 use tui::ui::cob::PatchItem;
 use tui::ui::theme::{style, Theme};
 use tui::ui::widget::context::Shortcuts;
 use tui::ui::widget::{Widget, WidgetComponent};
 use tui::ui::widget::container::Tabs;
 use tui::ui::widget::label::{self};
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State};
 use super::super::common;
 use super::ListCid;
 pub struct IdSelect {
     theme: Theme,
     browser: Widget<common::ui::PatchBrowser>,
 }
 impl IdSelect {
     pub fn new(theme: Theme, browser: Widget<common::ui::PatchBrowser>) -> Self {
         Self { theme, browser }
     }
     pub fn items(&self) -> &Vec<PatchItem> {
         self.browser.items()
     }
     pub fn shortcuts(&self) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::PatchBrowser,
             tui::ui::shortcuts(
                 &self.theme,
                 vec![
                     tui::ui::shortcut(&self.theme, "enter", "select"),
                     tui::ui::shortcut(&self.theme, "q", "quit"),
                 ],
             ),
         )]
         .iter()
         .cloned()
         .collect()
     }
 }
 impl WidgetComponent for IdSelect {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.browser.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.browser.view(frame, area);
     }
     fn state(&self) -> State {
         self.browser.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.browser.perform(cmd)
     }
 }
 pub struct OperationSelect {
     theme: Theme,
     browser: Widget<common::ui::PatchBrowser>,
 }
 impl OperationSelect {
     pub fn new(theme: Theme, browser: Widget<common::ui::PatchBrowser>) -> Self {
         Self { theme, browser }
     }
     pub fn items(&self) -> &Vec<PatchItem> {
         self.browser.items()
     }
     pub fn shortcuts(&self) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::PatchBrowser,
             tui::ui::shortcuts(
                 &self.theme,
                 vec![
                     tui::ui::shortcut(&self.theme, "enter", "show"),
                     tui::ui::shortcut(&self.theme, "c", "checkout"),
                     tui::ui::shortcut(&self.theme, "m", "comment"),
                     tui::ui::shortcut(&self.theme, "e", "edit"),
                     tui::ui::shortcut(&self.theme, "d", "delete"),
                     tui::ui::shortcut(&self.theme, "q", "quit"),
                 ],
             ),
         )]
         .iter()
         .cloned()
         .collect()
     }
 }
 impl WidgetComponent for OperationSelect {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.browser.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.browser.view(frame, area);
     }
     fn state(&self) -> State {
         self.browser.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.browser.perform(cmd)
     }
 }
 pub fn list_navigation(theme: &Theme) -> Widget<Tabs> {
     tui::ui::tabs(
         theme,
         vec![label::reversable("Patches").style(style::cyan())],
     )
 }
 pub fn id_select(
     theme: &Theme,
     context: &Context,
     filter: Filter,
     selected: Option<(PatchId, Patch)>,
 ) -> Widget<IdSelect> {
     let browser = Widget::new(common::ui::PatchBrowser::new(
         theme, context, filter, selected,
     ));
     Widget::new(IdSelect::new(theme.clone(), browser))
 }
 pub fn operation_select(
     theme: &Theme,
     context: &Context,
     filter: Filter,
     selected: Option<(PatchId, Patch)>,
 ) -> Widget<OperationSelect> {
     let browser = Widget::new(common::ui::PatchBrowser::new(
         theme, context, filter, selected,
     ));
     Widget::new(OperationSelect::new(theme.clone(), browser))
 }

deleted bin/commands/patch/suite.rs

@@ -1,287 +0,0 @@

 #[path = "suite/event.rs"]
 mod event;
 #[path = "suite/page.rs"]
 mod page;
 #[path = "suite/ui.rs"]
 mod ui;
 use std::hash::Hash;
 use anyhow::Result;
 use radicle::cob::patch::PatchId;
 use tuirealm::application::PollStrategy;
 use tuirealm::event::Key;
 use tuirealm::{Application, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::cob;
 use tui::cob::patch::Filter;
 use tui::context::Context;
 use tui::ui::subscription;
 use tui::ui::theme::Theme;
 use tui::{Exit, PageStack, Tui};
 use page::{ListView, PatchView};
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum ListCid {
     Header,
     PatchBrowser,
     Context,
     Shortcuts,
 }
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub enum PatchCid {
     Header,
     Activity,
     Files,
     Context,
     Shortcuts,
 }
 /// All component ids known to this application.
 #[derive(Debug, Default, Eq, PartialEq, Clone, Hash)]
 pub enum Cid {
     List(ListCid),
     Patch(PatchCid),
     #[default]
     GlobalListener,
     Popup,
 }
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum PatchMessage {
     Show(PatchId),
     Leave,
 }
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum PopupMessage {
     Info(String),
     Warning(String),
     Error(String),
     Hide,
 }
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum Message {
     Patch(PatchMessage),
     NavigationChanged(u16),
     FormSubmitted(String),
     Popup(PopupMessage),
     #[default]
     Tick,
     Quit,
     Batch(Vec<Message>),
 }
 #[allow(dead_code)]
 pub struct App {
     context: Context,
     pages: PageStack<Cid, Message>,
     theme: Theme,
     filter: Filter,
     quit: bool,
 }
 /// Creates a new application using a tui-realm-application, mounts all
 /// components and sets focus to a default one.
 #[allow(dead_code)]
 impl App {
     pub fn new(context: Context, filter: Filter) -> Self {
         Self {
             context,
             pages: PageStack::default(),
             theme: Theme::default(),
             filter,
             quit: false,
         }
     }
     fn view_list(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
     ) -> Result<()> {
         let home = Box::new(ListView::new(theme.clone(), self.filter.clone()));
         self.pages.push(home, app, &self.context, theme)?;
         Ok(())
     }
     fn view_patch(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         id: PatchId,
         theme: &Theme,
     ) -> Result<()> {
         let repo = self.context.repository();
         if let Some(patch) = cob::patch::find(repo, &id)? {
             let view = Box::new(PatchView::new(theme.clone(), (id, patch)));
             self.pages.push(view, app, &self.context, theme)?;
             Ok(())
         } else {
             Err(anyhow::anyhow!(
                 "Could not mount 'page::PatchView'. Patch not found."
             ))
         }
     }
     fn process(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         message: Message,
     ) -> Result<Option<Message>> {
         let theme = Theme::default();
         match message {
             Message::Batch(messages) => {
                 let mut results = vec![];
                 for message in messages {
                     if let Some(result) = self.process(app, message)? {
                         results.push(result);
                     }
                 }
                 match results.len() {
 => Ok(None),
 => Ok(Some(results[0].to_owned())),
                     _ => Ok(Some(Message::Batch(results))),
                 }
             }
             Message::Patch(PatchMessage::Show(id)) => {
                 self.view_patch(app, id, &theme)?;
                 Ok(None)
             }
             Message::Patch(PatchMessage::Leave) => {
                 self.pages.pop(app)?;
                 Ok(None)
             }
             Message::Popup(PopupMessage::Info(info)) => {
                 self.show_info_popup(app, &theme, &info)?;
                 Ok(None)
             }
             Message::Popup(PopupMessage::Warning(warning)) => {
                 self.show_warning_popup(app, &theme, &warning)?;
                 Ok(None)
             }
             Message::Popup(PopupMessage::Error(error)) => {
                 self.show_error_popup(app, &theme, &error)?;
                 Ok(None)
             }
             Message::Popup(PopupMessage::Hide) => {
                 self.hide_popup(app)?;
                 Ok(None)
             }
             Message::Quit => {
                 self.quit = true;
                 Ok(None)
             }
             _ => self
                 .pages
                 .peek_mut()?
                 .update(app, &self.context, &theme, message),
         }
     }
     fn show_info_popup(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
         message: &str,
     ) -> Result<()> {
         let popup = tui::ui::info(theme, message);
         app.remount(Cid::Popup, popup.to_boxed(), vec![])?;
         app.active(&Cid::Popup)?;
         Ok(())
     }
     fn show_warning_popup(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
         message: &str,
     ) -> Result<()> {
         let popup = tui::ui::warning(theme, message);
         app.remount(Cid::Popup, popup.to_boxed(), vec![])?;
         app.active(&Cid::Popup)?;
         Ok(())
     }
     fn show_error_popup(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         theme: &Theme,
         message: &str,
     ) -> Result<()> {
         let popup = tui::ui::error(theme, message);
         app.remount(Cid::Popup, popup.to_boxed(), vec![])?;
         app.active(&Cid::Popup)?;
         Ok(())
     }
     fn hide_popup(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.blur()?;
         app.umount(&Cid::Popup)?;
         Ok(())
     }
 }
 impl Tui<Cid, Message, ()> for App {
     fn init(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         self.view_list(app, &self.theme.clone())?;
         // Add global key listener and subscribe to key events
         let global = tui::ui::global_listener().to_boxed();
         app.mount(
             Cid::GlobalListener,
             global,
             vec![Sub::new(
                 subscription::quit_clause(Key::Char('q')),
                 SubClause::Always,
             )],
         )?;
         Ok(())
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         if let Ok(page) = self.pages.peek_mut() {
             page.view(app, frame);
         }
         if app.mounted(&Cid::Popup) {
             app.view(&Cid::Popup, frame, frame.size());
         }
     }
     fn update(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<bool> {
         match app.tick(PollStrategy::Once) {
             Ok(messages) if !messages.is_empty() => {
                 for message in messages {
                     let mut msg = Some(message);
                     while msg.is_some() {
                         msg = self.process(app, msg.unwrap())?;
                     }
                 }
                 Ok(true)
             }
             _ => Ok(false),
         }
     }
     fn exit(&self) -> Option<Exit<()>> {
         if self.quit {
             return Some(Exit { value: None });
         }
         None
     }
 }

deleted bin/commands/patch/suite/event.rs

@@ -1,139 +0,0 @@

 use radicle_tui::ui::state::ItemState;
 use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection};
 use tuirealm::event::{Event, Key, KeyEvent};
 use tuirealm::{MockComponent, NoUserEvent, State, StateValue};
 use radicle_tui::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer, Popup};
 use radicle_tui::ui::widget::context::{ContextBar, Shortcuts};
 use radicle_tui::ui::widget::list::PropertyList;
 use radicle_tui::ui::widget::Widget;
 use super::super::common;
 use super::{ui, Message, PatchMessage, PopupMessage};
 /// Since the framework does not know the type of messages that are being
 /// passed around in the app, the following handlers need to be implemented for
 /// each component used.
 ///
 /// TODO: should handle `Event::WindowResize`, which is not emitted by `termion`.
 impl tuirealm::Component<Message, NoUserEvent> for Widget<GlobalListener> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent {
                 code: Key::Char('q'),
                 ..
             }) => Some(Message::Quit),
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<AppHeader> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Tab, .. }) => {
                 match self.perform(Cmd::Move(MoveDirection::Right)) {
                     CmdResult::Changed(State::One(StateValue::U16(index))) => {
                         Some(Message::NavigationChanged(index))
                     }
                     _ => None,
                 }
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<common::ui::PatchBrowser> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Up, .. })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('k'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Up));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Down, ..
             })
             | Event::Keyboard(KeyEvent {
                 code: Key::Char('j'),
                 ..
             }) => {
                 self.perform(Cmd::Move(MoveDirection::Down));
                 Some(Message::Tick)
             }
             Event::Keyboard(KeyEvent {
                 code: Key::Enter, ..
             }) => match self.perform(Cmd::Submit) {
                 CmdResult::Submit(state) => {
                     let selected = ItemState::try_from(state).ok()?.selected()?;
                     let item = self.items().get(selected)?;
                     Some(Message::Patch(PatchMessage::Show(item.id().to_owned())))
                 }
                 _ => None,
             },
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ui::Activity> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {
                 Some(Message::Patch(PatchMessage::Leave))
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ui::Files> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {
                 Some(Message::Patch(PatchMessage::Leave))
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Popup> {
     fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {
         match event {
             Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {
                 Some(Message::Popup(PopupMessage::Hide))
             }
             _ => None,
         }
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<LabeledContainer> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<PropertyList> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<ContextBar> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }
 impl tuirealm::Component<Message, NoUserEvent> for Widget<Shortcuts> {
     fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {
         None
     }
 }

deleted bin/commands/patch/suite/page.rs

@@ -1,346 +0,0 @@

 use std::collections::HashMap;
 use anyhow::Result;
 use radicle::cob::patch::{Patch, PatchId};
 use tui::ui::state::ItemState;
 use tuirealm::{AttrValue, Attribute, Frame, NoUserEvent, Sub, SubClause};
 use radicle_tui as tui;
 use tui::cob::patch::Filter;
 use tui::context::Context;
 use tui::ui::theme::Theme;
 use tui::ui::widget::context::{Progress, Shortcuts};
 use tui::ui::widget::Widget;
 use tui::ui::{layout, subscription};
 use tui::ViewPage;
 use super::{ui, Application, Cid, ListCid, Message, PatchCid};
 ///
 /// Home
 ///
 pub struct ListView {
     active_component: ListCid,
     shortcuts: HashMap<ListCid, Widget<Shortcuts>>,
     filter: Filter,
 }
 impl ListView {
     pub fn new(theme: Theme, filter: Filter) -> Self {
         let shortcuts = Self::build_shortcuts(&theme);
         Self {
             active_component: ListCid::PatchBrowser,
             shortcuts,
             filter,
         }
     }
     fn build_shortcuts(theme: &Theme) -> HashMap<ListCid, Widget<Shortcuts>> {
         [(
             ListCid::PatchBrowser,
             tui::ui::shortcuts(
                 theme,
                 vec![
                     tui::ui::shortcut(theme, "tab", "section"),
                     tui::ui::shortcut(theme, "↑/↓", "navigate"),
                     tui::ui::shortcut(theme, "enter", "show"),
                     tui::ui::shortcut(theme, "q", "quit"),
                 ],
             ),
         )]
         .iter()
         .cloned()
         .collect()
     }
     fn update_context(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let state = app.state(&Cid::List(ListCid::PatchBrowser))?;
         let progress = match ItemState::try_from(state) {
             Ok(state) => Progress::Step(
                 state
                     .selected()
                     .map(|s| s.saturating_add(1))
                     .unwrap_or_default(),
                 state.len(),
             ),
             Err(_) => Progress::None,
         };
         let context = ui::browse_context(context, theme, progress);
         app.remount(Cid::List(ListCid::Context), context.to_boxed(), vec![])?;
         Ok(())
     }
     fn update_shortcuts(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: ListCid,
     ) -> Result<()> {
         if let Some(shortcuts) = self.shortcuts.get(&cid) {
             app.remount(
                 Cid::List(ListCid::Shortcuts),
                 shortcuts.clone().to_boxed(),
                 vec![],
             )?;
         }
         Ok(())
     }
 }
 impl ViewPage<Cid, Message> for ListView {
     fn mount(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let navigation = ui::list_navigation(theme);
         let header = tui::ui::app_header(context, theme, Some(navigation)).to_boxed();
         let patch_browser = ui::patches(theme, context, self.filter.clone(), None).to_boxed();
         app.remount(Cid::List(ListCid::Header), header, vec![])?;
         app.remount(Cid::List(ListCid::PatchBrowser), patch_browser, vec![])?;
         app.active(&Cid::List(self.active_component.clone()))?;
         self.update_shortcuts(app, self.active_component.clone())?;
         self.update_context(app, context, theme)?;
         Ok(())
     }
     fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.umount(&Cid::List(ListCid::Header))?;
         app.umount(&Cid::List(ListCid::PatchBrowser))?;
         app.umount(&Cid::List(ListCid::Context))?;
         app.umount(&Cid::List(ListCid::Shortcuts))?;
         Ok(())
     }
     fn update(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         _message: Message,
     ) -> Result<Option<Message>> {
         self.update_context(app, context, theme)?;
         Ok(None)
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         let area = frame.size();
         let context_h = app
             .query(&Cid::List(ListCid::Context), Attribute::Height)
             .unwrap_or_default()
             .unwrap_or(AttrValue::Size(0))
             .unwrap_size();
         let shortcuts_h = 1u16;
         let layout = layout::full_page(area, context_h, shortcuts_h);
         app.view(&Cid::List(ListCid::Header), frame, layout.navigation);
         app.view(
             &Cid::List(self.active_component.clone()),
             frame,
             layout.component,
         );
         app.view(&Cid::List(ListCid::Context), frame, layout.context);
         app.view(&Cid::List(ListCid::Shortcuts), frame, layout.shortcuts);
     }
     fn subscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.subscribe(
             &Cid::List(ListCid::Header),
             Sub::new(subscription::navigation_clause(), SubClause::Always),
         )?;
         Ok(())
     }
     fn unsubscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.unsubscribe(
             &Cid::List(ListCid::Header),
             subscription::navigation_clause(),
         )?;
         Ok(())
     }
 }
 ///
 /// Patch detail page
 ///
 pub struct PatchView {
     active_component: PatchCid,
     patch: (PatchId, Patch),
     shortcuts: HashMap<PatchCid, Widget<Shortcuts>>,
 }
 impl PatchView {
     pub fn new(theme: Theme, patch: (PatchId, Patch)) -> Self {
         let shortcuts = Self::build_shortcuts(&theme);
         PatchView {
             active_component: PatchCid::Activity,
             patch,
             shortcuts,
         }
     }
     fn build_shortcuts(theme: &Theme) -> HashMap<PatchCid, Widget<Shortcuts>> {
         [
             (
                 PatchCid::Activity,
                 tui::ui::shortcuts(
                     theme,
                     vec![
                         tui::ui::shortcut(theme, "esc", "back"),
                         tui::ui::shortcut(theme, "tab", "section"),
                         tui::ui::shortcut(theme, "q", "quit"),
                     ],
                 ),
             ),
             (
                 PatchCid::Files,
                 tui::ui::shortcuts(
                     theme,
                     vec![
                         tui::ui::shortcut(theme, "esc", "back"),
                         tui::ui::shortcut(theme, "tab", "section"),
                         tui::ui::shortcut(theme, "q", "quit"),
                     ],
                 ),
             ),
         ]
         .iter()
         .cloned()
         .collect()
     }
     fn update_shortcuts(
         &self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         cid: PatchCid,
     ) -> Result<()> {
         if let Some(shortcuts) = self.shortcuts.get(&cid) {
             app.remount(
                 Cid::Patch(PatchCid::Shortcuts),
                 shortcuts.clone().to_boxed(),
                 vec![],
             )?;
         }
         Ok(())
     }
 }
 impl ViewPage<Cid, Message> for PatchView {
     fn mount(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         let navigation = ui::navigation(theme);
         let header = tui::ui::app_header(context, theme, Some(navigation)).to_boxed();
         let activity = ui::activity(theme).to_boxed();
         let files = ui::files(theme).to_boxed();
         let context = ui::context(context, theme, self.patch.clone()).to_boxed();
         app.remount(Cid::Patch(PatchCid::Header), header, vec![])?;
         app.remount(Cid::Patch(PatchCid::Activity), activity, vec![])?;
         app.remount(Cid::Patch(PatchCid::Files), files, vec![])?;
         app.remount(Cid::Patch(PatchCid::Context), context, vec![])?;
         let active_component = Cid::Patch(self.active_component.clone());
         app.active(&active_component)?;
         self.update_shortcuts(app, self.active_component.clone())?;
         Ok(())
     }
     fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.umount(&Cid::Patch(PatchCid::Header))?;
         app.umount(&Cid::Patch(PatchCid::Activity))?;
         app.umount(&Cid::Patch(PatchCid::Files))?;
         app.umount(&Cid::Patch(PatchCid::Context))?;
         app.umount(&Cid::Patch(PatchCid::Shortcuts))?;
         Ok(())
     }
     fn update(
         &mut self,
         app: &mut Application<Cid, Message, NoUserEvent>,
         _context: &Context,
         _theme: &Theme,
         message: Message,
     ) -> Result<Option<Message>> {
         if let Message::NavigationChanged(index) = message {
             self.active_component = PatchCid::from(index as usize);
             let active_component = Cid::Patch(self.active_component.clone());
             app.active(&active_component)?;
             self.update_shortcuts(app, self.active_component.clone())?;
         }
         Ok(None)
     }
     fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {
         let area = frame.size();
         let context_h = app
             .query(&Cid::List(ListCid::Context), Attribute::Height)
             .unwrap_or_default()
             .unwrap_or(AttrValue::Size(0))
             .unwrap_size();
         let shortcuts_h = 1u16;
         let layout = layout::full_page(area, context_h, shortcuts_h);
         app.view(&Cid::Patch(PatchCid::Header), frame, layout.navigation);
         app.view(
             &Cid::Patch(self.active_component.clone()),
             frame,
             layout.component,
         );
         app.view(&Cid::Patch(PatchCid::Context), frame, layout.context);
         app.view(&Cid::Patch(PatchCid::Shortcuts), frame, layout.shortcuts);
     }
     fn subscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.subscribe(
             &Cid::Patch(PatchCid::Header),
             Sub::new(subscription::navigation_clause(), SubClause::Always),
         )?;
         Ok(())
     }
     fn unsubscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {
         app.unsubscribe(
             &Cid::Patch(PatchCid::Header),
             subscription::navigation_clause(),
         )?;
         Ok(())
     }
 }
 impl From<usize> for PatchCid {
     fn from(index: usize) -> Self {
         match index {
 => PatchCid::Activity,
 => PatchCid::Files,
             _ => PatchCid::Activity,
         }
     }
 }

deleted bin/commands/patch/suite/ui.rs

@@ -1,171 +0,0 @@

 use radicle::cob::patch::{Patch, PatchId};
 use radicle::node::AliasStore;
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State};
 use radicle_tui as tui;
 use tui::cob::patch::Filter;
 use tui::context::Context;
 use tui::ui::cob;
 use tui::ui::layout;
 use tui::ui::theme::{style, Theme};
 use tui::ui::widget::{Widget, WidgetComponent};
 use tui::ui::widget::container::Tabs;
 use tui::ui::widget::context::{ContextBar, Progress};
 use tui::ui::widget::label::{self, Label};
 use super::super::common;
 pub struct Activity {
     label: Widget<Label>,
 }
 impl Activity {
     pub fn new(label: Widget<Label>) -> Self {
         Self { label }
     }
 }
 impl WidgetComponent for Activity {
     fn view(&mut self, _properties: &Props, frame: &mut Frame, area: Rect) {
         let label_w = self
             .label
             .query(Attribute::Width)
             .unwrap_or(AttrValue::Size(1))
             .unwrap_size();
         self.label
             .view(frame, layout::centered_label(label_w, area));
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 pub struct Files {
     label: Widget<Label>,
 }
 impl Files {
     pub fn new(label: Widget<Label>) -> Self {
         Self { label }
     }
 }
 impl WidgetComponent for Files {
     fn view(&mut self, _properties: &Props, frame: &mut Frame, area: Rect) {
         let label_w = self
             .label
             .query(Attribute::Width)
             .unwrap_or(AttrValue::Size(1))
             .unwrap_size();
         self.label
             .view(frame, layout::centered_label(label_w, area));
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 pub fn list_navigation(theme: &Theme) -> Widget<Tabs> {
     tui::ui::tabs(
         theme,
         vec![label::reversable("Patches").style(style::magenta())],
     )
 }
 pub fn navigation(theme: &Theme) -> Widget<Tabs> {
     tui::ui::tabs(
         theme,
         vec![
             label::reversable("Activity").style(style::magenta()),
             label::reversable("Files").style(style::magenta()),
         ],
     )
 }
 pub fn patches(
     theme: &Theme,
     context: &Context,
     filter: Filter,
     selected: Option<(PatchId, Patch)>,
 ) -> Widget<common::ui::PatchBrowser> {
     Widget::new(common::ui::PatchBrowser::new(
         theme, context, filter, selected,
     ))
 }
 pub fn activity(_theme: &Theme) -> Widget<Activity> {
     let not_implemented = label::default("not implemented").style(style::reset());
     let activity = Activity::new(not_implemented);
     Widget::new(activity)
 }
 pub fn files(_theme: &Theme) -> Widget<Files> {
     let not_implemented = label::default("not implemented").style(style::reset());
     let files = Files::new(not_implemented);
     Widget::new(files)
 }
 pub fn context(context: &Context, theme: &Theme, patch: (PatchId, Patch)) -> Widget<ContextBar> {
     let (id, patch) = patch;
     let (_, rev) = patch.latest();
     let is_you = *patch.author().id() == context.profile().did();
     let id = cob::format::cob(&id);
     let title = patch.title();
     let author = patch.author().id();
     let alias = context.profile().aliases().alias(author);
     let author = cob::format_author(author, &alias, is_you);
     let comments = rev.discussion().len();
     tui::ui::widget::context::bar(theme, "Patch", &id, title, &author, &comments.to_string())
 }
 pub fn browse_context(context: &Context, theme: &Theme, progress: Progress) -> Widget<ContextBar> {
     use radicle::cob::patch::State;
     let mut draft = 0;
     let mut open = 0;
     let mut archived = 0;
     let mut merged = 0;
     let patches = context.patches().as_ref().unwrap();
     for (_, patch) in patches {
         match patch.state() {
             State::Draft => draft += 1,
             State::Open { conflicts: _ } => open += 1,
             State::Archived => archived += 1,
             State::Merged {
                 commit: _,
                 revision: _,
             } => merged += 1,
         }
     }
     tui::ui::widget::context::bar(
         theme,
         "Browse",
         "",
         "",
         &format!("{draft} draft | {open} open | {archived} archived | {merged} merged"),
         &progress.to_string(),
     )
 }

deleted src/cob.rs

@@ -1,39 +0,0 @@

 use std::str::FromStr;
 use anyhow::Result;
 use radicle::cob::Label;
 use radicle::prelude::Did;
 pub mod format;
 pub mod inbox;
 pub mod issue;
 pub mod patch;
 pub fn parse_labels(input: String) -> Result<Vec<Label>> {
     let mut labels = vec![];
     if !input.is_empty() {
         for name in input.split(',') {
             match Label::new(name.trim()) {
                 Ok(label) => labels.push(label),
                 Err(err) => return Err(anyhow::anyhow!(err).context("Can't parse labels.")),
             }
         }
     }
     Ok(labels)
 }
 pub fn parse_assignees(input: String) -> Result<Vec<Did>> {
     let mut assignees = vec![];
     if !input.is_empty() {
         for did in input.split(',') {
             match Did::from_str(&format!("did:key:{}", did)) {
                 Ok(did) => assignees.push(did),
                 Err(err) => return Err(anyhow::anyhow!(err).context("Can't parse assignees.")),
             }
         }
     }
     Ok(assignees)
 }

deleted src/cob/format.rs

@@ -1,7 +0,0 @@

 use radicle::identity::Did;
 /// Format a DID.
 pub fn did(did: &Did) -> String {
     let nid = did.as_key().to_human();
     format!("{}…{}", &nid[..7], &nid[nid.len() - 7..])
 }

deleted src/cob/inbox.rs

@@ -1,38 +0,0 @@

 use anyhow::Result;
 use radicle::node::notifications::Notification;
 use radicle::storage::git::Repository;
 use radicle::Profile;
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub struct Filter {}
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct SortBy {
     pub reverse: bool,
     pub field: &'static str,
 }
 impl Default for SortBy {
     fn default() -> Self {
         Self {
             reverse: true,
             field: "timestamp",
         }
     }
 }
 pub fn all(repository: &Repository, profile: &Profile) -> Result<Vec<Notification>> {
     let all = profile
         .notifications_mut()?
         .by_repo(&repository.id, "timestamp")?
         .collect::<Vec<_>>();
     let mut notifications = vec![];
     for n in all {
         let n = n?;
         notifications.push(n);
     }
     Ok(notifications)
 }

deleted src/cob/issue.rs

@@ -1,150 +0,0 @@

 use std::fmt::Display;
 use anyhow::Result;
 use radicle::cob::issue::{Issue, IssueId, Issues};
 use radicle::cob::Label;
 use radicle::issue::CloseReason;
 use radicle::prelude::{Did, Signer};
 use radicle::storage::git::Repository;
 use radicle::{issue, Profile};
 use super::format;
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum State {
     #[default]
     Open,
     Solved,
     Closed,
 }
 impl Display for State {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let state = match self {
             State::Open => "open",
             State::Solved => "solved",
             State::Closed => "closed",
         };
         f.write_str(state)
     }
 }
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub struct Filter {
     state: Option<State>,
     assigned: bool,
     assignees: Vec<Did>,
 }
 impl Filter {
     pub fn with_state(mut self, state: Option<State>) -> Self {
         self.state = state;
         self
     }
     pub fn with_assgined(mut self, assigned: bool) -> Self {
         self.assigned = assigned;
         self
     }
     pub fn with_assginee(mut self, assignee: Did) -> Self {
         self.assignees.push(assignee);
         self
     }
     pub fn matches(&self, profile: &Profile, issue: &Issue) -> bool {
         let matches_state = match self.state {
             Some(State::Open) => matches!(issue.state(), issue::State::Open),
             Some(State::Solved) => matches!(
                 issue.state(),
                 issue::State::Closed {
                     reason: CloseReason::Solved
                 }
             ),
             Some(State::Closed) => matches!(issue.state(), issue::State::Closed { .. }),
             None => true,
         };
         let matches_assgined = self
             .assigned
             .then(|| {
                 issue
                     .assignees()
                     .collect::<Vec<_>>()
                     .contains(&&profile.did())
             })
             .unwrap_or(true);
         let matches_assignees = (!self.assignees.is_empty())
             .then(|| {
                 self.assignees
                     .iter()
                     .any(|other| issue.assignees().collect::<Vec<_>>().contains(&other))
             })
             .unwrap_or(true);
         matches_state && matches_assgined && matches_assignees
     }
 }
 impl ToString for Filter {
     fn to_string(&self) -> String {
         let mut filter = String::new();
         filter.push(' ');
         if let Some(state) = &self.state {
             filter.push_str(&format!("is:{}", state));
             filter.push(' ');
         }
         if self.assigned {
             filter.push_str("is:assigned");
             filter.push(' ');
         }
         if !self.assignees.is_empty() {
             filter.push_str("assignees:");
             filter.push('[');
             let mut assignees = self.assignees.iter().peekable();
             while let Some(assignee) = assignees.next() {
                 filter.push_str(&format::did(assignee));
                 if assignees.peek().is_some() {
                     filter.push(',');
                 }
             }
             filter.push(']');
         }
         filter
     }
 }
 pub fn all(repository: &Repository) -> Result<Vec<(IssueId, Issue)>> {
     let patches = Issues::open(repository)?
         .all()
         .map(|iter| iter.flatten().collect::<Vec<_>>())?;
     Ok(patches
         .into_iter()
         .map(|(id, issue)| (id, issue))
         .collect::<Vec<_>>())
 }
 pub fn find(repository: &Repository, id: &IssueId) -> Result<Option<Issue>> {
     let issues = Issues::open(repository)?;
     Ok(issues.get(id)?)
 }
 pub fn create<G: Signer>(
     repository: &Repository,
     signer: &G,
     title: String,
     description: String,
     labels: &[Label],
     assignees: &[Did],
 ) -> Result<IssueId> {
     let mut issues = Issues::open(repository)?;
     let issue = issues.create(title, description.trim(), labels, assignees, [], signer)?;
     Ok(*issue.id())
 }

deleted src/cob/patch.rs

@@ -1,128 +0,0 @@

 use std::fmt::Display;
 use anyhow::Result;
 use radicle::cob::patch::{Patch, PatchId, Patches};
 use radicle::identity::Did;
 use radicle::storage::git::Repository;
 use radicle::{patch, Profile};
 use super::format;
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum State {
     Draft,
     #[default]
     Open,
     Merged,
     Archived,
 }
 impl Display for State {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let state = match self {
             State::Draft => "draft",
             State::Open => "open",
             State::Merged => "merged",
             State::Archived => "archived",
         };
         f.write_str(state)
     }
 }
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub struct Filter {
     state: Option<State>,
     authored: bool,
     authors: Vec<Did>,
 }
 impl Filter {
     pub fn with_state(mut self, state: Option<State>) -> Self {
         self.state = state;
         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
     }
     pub fn matches(&self, profile: &Profile, patch: &Patch) -> bool {
         let matches_state = match self.state {
             Some(State::Draft) => matches!(patch.state(), patch::State::Draft),
             Some(State::Open) => matches!(patch.state(), patch::State::Open { .. }),
             Some(State::Merged) => matches!(patch.state(), patch::State::Merged { .. }),
             Some(State::Archived) => matches!(patch.state(), patch::State::Archived),
             None => true,
         };
         let matches_authored = self
             .authored
             .then(|| *patch.author().id() == profile.did())
             .unwrap_or(true);
         let matches_authors = (!self.authors.is_empty())
             .then(|| {
                 self.authors
                     .iter()
                     .any(|other| *patch.author().id() == *other)
             })
             .unwrap_or(true);
         matches_state && matches_authored && matches_authors
     }
 }
 impl ToString for Filter {
     fn to_string(&self) -> String {
         let mut filter = String::new();
         filter.push(' ');
         if let Some(state) = &self.state {
             filter.push_str(&format!("is:{}", state));
             filter.push(' ');
         }
         if self.authored {
             filter.push_str("is:authored");
             filter.push(' ');
         }
         if !self.authors.is_empty() {
             filter.push_str("authors:");
             filter.push('[');
             let mut authors = self.authors.iter().peekable();
             while let Some(author) = authors.next() {
                 filter.push_str(&format::did(author));
                 if authors.peek().is_some() {
                     filter.push(',');
                 }
             }
             filter.push(']');
         }
         filter
     }
 }
 pub fn all(repository: &Repository) -> Result<Vec<(PatchId, Patch)>> {
     let patches = Patches::open(repository)?
         .all()
         .map(|iter| iter.flatten().collect::<Vec<_>>())?;
     Ok(patches
         .into_iter()
         .map(|(id, patch)| (id, patch))
         .collect::<Vec<_>>())
 }
 pub fn find(repository: &Repository, id: &PatchId) -> Result<Option<Patch>> {
     let patches = Patches::open(repository)?;
     Ok(patches.get(id)?)
 }

added src/common.rs

@@ -0,0 +1,3 @@

+	`pub mod cob;`
+	`pub mod context;`
+	`pub mod log;`

added src/common/cob.rs

@@ -0,0 +1,39 @@

 use std::str::FromStr;
 use anyhow::Result;
 use radicle::cob::Label;
 use radicle::prelude::Did;
 pub mod format;
 pub mod inbox;
 pub mod issue;
 pub mod patch;
 pub fn parse_labels(input: String) -> Result<Vec<Label>> {
     let mut labels = vec![];
     if !input.is_empty() {
         for name in input.split(',') {
             match Label::new(name.trim()) {
                 Ok(label) => labels.push(label),
                 Err(err) => return Err(anyhow::anyhow!(err).context("Can't parse labels.")),
             }
         }
     }
     Ok(labels)
 }
 pub fn parse_assignees(input: String) -> Result<Vec<Did>> {
     let mut assignees = vec![];
     if !input.is_empty() {
         for did in input.split(',') {
             match Did::from_str(&format!("did:key:{}", did)) {
                 Ok(did) => assignees.push(did),
                 Err(err) => return Err(anyhow::anyhow!(err).context("Can't parse assignees.")),
             }
         }
     }
     Ok(assignees)
 }

added src/common/cob/format.rs

@@ -0,0 +1,7 @@

 use radicle::identity::Did;
 /// Format a DID.
 pub fn did(did: &Did) -> String {
     let nid = did.as_key().to_human();
     format!("{}…{}", &nid[..7], &nid[nid.len() - 7..])
 }

added src/common/cob/inbox.rs

@@ -0,0 +1,38 @@

 use anyhow::Result;
 use radicle::node::notifications::Notification;
 use radicle::storage::git::Repository;
 use radicle::Profile;
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub struct Filter {}
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct SortBy {
     pub reverse: bool,
     pub field: &'static str,
 }
 impl Default for SortBy {
     fn default() -> Self {
         Self {
             reverse: true,
             field: "timestamp",
         }
     }
 }
 pub fn all(repository: &Repository, profile: &Profile) -> Result<Vec<Notification>> {
     let all = profile
         .notifications_mut()?
         .by_repo(&repository.id, "timestamp")?
         .collect::<Vec<_>>();
     let mut notifications = vec![];
     for n in all {
         let n = n?;
         notifications.push(n);
     }
     Ok(notifications)
 }

added src/common/cob/issue.rs

@@ -0,0 +1,150 @@

 use std::fmt::Display;
 use anyhow::Result;
 use radicle::cob::issue::{Issue, IssueId, Issues};
 use radicle::cob::Label;
 use radicle::issue::CloseReason;
 use radicle::prelude::{Did, Signer};
 use radicle::storage::git::Repository;
 use radicle::{issue, Profile};
 use super::format;
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum State {
     #[default]
     Open,
     Solved,
     Closed,
 }
 impl Display for State {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let state = match self {
             State::Open => "open",
             State::Solved => "solved",
             State::Closed => "closed",
         };
         f.write_str(state)
     }
 }
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub struct Filter {
     state: Option<State>,
     assigned: bool,
     assignees: Vec<Did>,
 }
 impl Filter {
     pub fn with_state(mut self, state: Option<State>) -> Self {
         self.state = state;
         self
     }
     pub fn with_assgined(mut self, assigned: bool) -> Self {
         self.assigned = assigned;
         self
     }
     pub fn with_assginee(mut self, assignee: Did) -> Self {
         self.assignees.push(assignee);
         self
     }
     pub fn matches(&self, profile: &Profile, issue: &Issue) -> bool {
         let matches_state = match self.state {
             Some(State::Open) => matches!(issue.state(), issue::State::Open),
             Some(State::Solved) => matches!(
                 issue.state(),
                 issue::State::Closed {
                     reason: CloseReason::Solved
                 }
             ),
             Some(State::Closed) => matches!(issue.state(), issue::State::Closed { .. }),
             None => true,
         };
         let matches_assgined = self
             .assigned
             .then(|| {
                 issue
                     .assignees()
                     .collect::<Vec<_>>()
                     .contains(&&profile.did())
             })
             .unwrap_or(true);
         let matches_assignees = (!self.assignees.is_empty())
             .then(|| {
                 self.assignees
                     .iter()
                     .any(|other| issue.assignees().collect::<Vec<_>>().contains(&other))
             })
             .unwrap_or(true);
         matches_state && matches_assgined && matches_assignees
     }
 }
 impl ToString for Filter {
     fn to_string(&self) -> String {
         let mut filter = String::new();
         filter.push(' ');
         if let Some(state) = &self.state {
             filter.push_str(&format!("is:{}", state));
             filter.push(' ');
         }
         if self.assigned {
             filter.push_str("is:assigned");
             filter.push(' ');
         }
         if !self.assignees.is_empty() {
             filter.push_str("assignees:");
             filter.push('[');
             let mut assignees = self.assignees.iter().peekable();
             while let Some(assignee) = assignees.next() {
                 filter.push_str(&format::did(assignee));
                 if assignees.peek().is_some() {
                     filter.push(',');
                 }
             }
             filter.push(']');
         }
         filter
     }
 }
 pub fn all(repository: &Repository) -> Result<Vec<(IssueId, Issue)>> {
     let patches = Issues::open(repository)?
         .all()
         .map(|iter| iter.flatten().collect::<Vec<_>>())?;
     Ok(patches
         .into_iter()
         .map(|(id, issue)| (id, issue))
         .collect::<Vec<_>>())
 }
 pub fn find(repository: &Repository, id: &IssueId) -> Result<Option<Issue>> {
     let issues = Issues::open(repository)?;
     Ok(issues.get(id)?)
 }
 pub fn create<G: Signer>(
     repository: &Repository,
     signer: &G,
     title: String,
     description: String,
     labels: &[Label],
     assignees: &[Did],
 ) -> Result<IssueId> {
     let mut issues = Issues::open(repository)?;
     let issue = issues.create(title, description.trim(), labels, assignees, [], signer)?;
     Ok(*issue.id())
 }

added src/common/cob/patch.rs

@@ -0,0 +1,128 @@

 use std::fmt::Display;
 use anyhow::Result;
 use radicle::cob::patch::{Patch, PatchId, Patches};
 use radicle::identity::Did;
 use radicle::storage::git::Repository;
 use radicle::{patch, Profile};
 use super::format;
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub enum State {
     Draft,
     #[default]
     Open,
     Merged,
     Archived,
 }
 impl Display for State {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let state = match self {
             State::Draft => "draft",
             State::Open => "open",
             State::Merged => "merged",
             State::Archived => "archived",
         };
         f.write_str(state)
     }
 }
 #[derive(Clone, Default, Debug, Eq, PartialEq)]
 pub struct Filter {
     state: Option<State>,
     authored: bool,
     authors: Vec<Did>,
 }
 impl Filter {
     pub fn with_state(mut self, state: Option<State>) -> Self {
         self.state = state;
         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
     }
     pub fn matches(&self, profile: &Profile, patch: &Patch) -> bool {
         let matches_state = match self.state {
             Some(State::Draft) => matches!(patch.state(), patch::State::Draft),
             Some(State::Open) => matches!(patch.state(), patch::State::Open { .. }),
             Some(State::Merged) => matches!(patch.state(), patch::State::Merged { .. }),
             Some(State::Archived) => matches!(patch.state(), patch::State::Archived),
             None => true,
         };
         let matches_authored = self
             .authored
             .then(|| *patch.author().id() == profile.did())
             .unwrap_or(true);
         let matches_authors = (!self.authors.is_empty())
             .then(|| {
                 self.authors
                     .iter()
                     .any(|other| *patch.author().id() == *other)
             })
             .unwrap_or(true);
         matches_state && matches_authored && matches_authors
     }
 }
 impl ToString for Filter {
     fn to_string(&self) -> String {
         let mut filter = String::new();
         filter.push(' ');
         if let Some(state) = &self.state {
             filter.push_str(&format!("is:{}", state));
             filter.push(' ');
         }
         if self.authored {
             filter.push_str("is:authored");
             filter.push(' ');
         }
         if !self.authors.is_empty() {
             filter.push_str("authors:");
             filter.push('[');
             let mut authors = self.authors.iter().peekable();
             while let Some(author) = authors.next() {
                 filter.push_str(&format::did(author));
                 if authors.peek().is_some() {
                     filter.push(',');
                 }
             }
             filter.push(']');
         }
         filter
     }
 }
 pub fn all(repository: &Repository) -> Result<Vec<(PatchId, Patch)>> {
     let patches = Patches::open(repository)?
         .all()
         .map(|iter| iter.flatten().collect::<Vec<_>>())?;
     Ok(patches
         .into_iter()
         .map(|(id, patch)| (id, patch))
         .collect::<Vec<_>>())
 }
 pub fn find(repository: &Repository, id: &PatchId) -> Result<Option<Patch>> {
     let patches = Patches::open(repository)?;
     Ok(patches.get(id)?)
 }

added src/common/context.rs

@@ -0,0 +1,184 @@

 use std::fmt::Display;
 use radicle::cob::issue::{Issue, IssueId};
 use radicle::cob::patch::{Patch, PatchId};
 use radicle::crypto::ssh::keystore::{Keystore, MemorySigner};
 use radicle::crypto::Signer;
 use radicle::identity::{Project, RepoId};
 use radicle::node::notifications::Notification;
 use radicle::profile::env::RAD_PASSPHRASE;
 use radicle::storage::git::Repository;
 use radicle::storage::{ReadRepository, ReadStorage};
 use radicle::Profile;
 use radicle_term as term;
 use term::{passphrase, spinner, Passphrase};
 use inquire::validator;
 use super::cob::inbox;
 /// Git revision parameter. Supports extended SHA-1 syntax.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Rev(String);
 impl From<String> for Rev {
     fn from(value: String) -> Self {
         Rev(value)
     }
 }
 impl Display for Rev {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.0)
     }
 }
 /// Application context that holds all the project data that are
 /// needed to render it.
 pub struct Context {
     profile: Profile,
     rid: RepoId,
     project: Project,
     repository: Repository,
     issues: Option<Vec<(IssueId, Issue)>>,
     patches: Option<Vec<(PatchId, Patch)>>,
     notifications: Vec<Notification>,
     signer: Option<Box<dyn Signer>>,
 }
 impl Context {
     pub fn new(profile: Profile, rid: RepoId) -> Result<Self, anyhow::Error> {
         let repository = profile.storage.repository(rid).unwrap();
         let project = repository.identity_doc()?.project()?;
         let notifications = inbox::all(&repository, &profile)?;
         let issues = None;
         let patches = None;
         let signer = None;
         Ok(Self {
             profile,
             rid,
             project,
             repository,
             issues,
             patches,
             notifications,
             signer,
         })
     }
     pub fn with_issues(mut self) -> Self {
         use super::cob::issue;
         self.issues = Some(issue::all(&self.repository).unwrap_or_default());
         self
     }
     pub fn with_patches(mut self) -> Self {
         use super::cob::patch;
         self.patches = Some(patch::all(&self.repository).unwrap_or_default());
         self
     }
     pub fn with_signer(mut self) -> Self {
         self.signer = signer(&self.profile).ok();
         self
     }
     pub fn profile(&self) -> &Profile {
         &self.profile
     }
     pub fn rid(&self) -> &RepoId {
         &self.rid
     }
     pub fn project(&self) -> &Project {
         &self.project
     }
     pub fn repository(&self) -> &Repository {
         &self.repository
     }
     pub fn issues(&self) -> &Option<Vec<(IssueId, Issue)>> {
         &self.issues
     }
     pub fn patches(&self) -> &Option<Vec<(PatchId, Patch)>> {
         &self.patches
     }
     pub fn notifications(&self) -> &Vec<Notification> {
         &self.notifications
     }
     #[allow(clippy::borrowed_box)]
     pub fn signer(&self) -> &Option<Box<dyn Signer>> {
         &self.signer
     }
     pub fn reload_patches(&mut self) {
         use super::cob::patch;
         self.patches = Some(patch::all(&self.repository).unwrap_or_default());
     }
     pub fn reload_issues(&mut self) {
         use super::cob::issue;
         self.issues = Some(issue::all(&self.repository).unwrap_or_default());
     }
 }
 /// Validates secret key passphrases.
 #[derive(Clone)]
 pub struct PassphraseValidator {
     keystore: Keystore,
 }
 impl PassphraseValidator {
     /// Create a new validator.
     pub fn new(keystore: Keystore) -> Self {
         Self { keystore }
     }
 }
 impl inquire::validator::StringValidator for PassphraseValidator {
     fn validate(
         &self,
         input: &str,
     ) -> Result<validator::Validation, inquire::error::CustomUserError> {
         let passphrase = Passphrase::from(input.to_owned());
         if self.keystore.is_valid_passphrase(&passphrase)? {
             Ok(validator::Validation::Valid)
         } else {
             Ok(validator::Validation::Invalid(
                 validator::ErrorMessage::from("Invalid passphrase, please try again"),
             ))
         }
     }
 }
 /// Get the signer. First we try getting it from ssh-agent, otherwise we prompt the user,
 /// if we're connected to a TTY.
 pub fn signer(profile: &Profile) -> anyhow::Result<Box<dyn Signer>> {
     if let Ok(signer) = profile.signer() {
         return Ok(signer);
     }
     let validator = PassphraseValidator::new(profile.keystore.clone());
     let passphrase = match passphrase(validator) {
         Ok(p) => p,
         Err(inquire::InquireError::NotTTY) => {
             return Err(anyhow::anyhow!(
                 "running in non-interactive mode, please set `{RAD_PASSPHRASE}` to unseal your key",
             ));
         }
         Err(e) => return Err(e.into()),
     };
     let spinner = spinner("Unsealing key...");
     let signer = MemorySigner::load(&profile.keystore, Some(passphrase))?;
     spinner.finish();
     Ok(signer.boxed())
 }

added src/common/log.rs

@@ -0,0 +1,15 @@

 use log::LevelFilter;
 use radicle::profile::Profile;
 pub fn enable(profile: &Profile, cmd: &str, op: &str) -> Result<(), anyhow::Error> {
     let logfile = format!(
         "{}/rad-tui-{}-{}.log",
         profile.home().path().to_string_lossy(),
         cmd,
         op,
     );
     simple_logging::log_to_file(logfile, LevelFilter::Info)?;
     Ok(())
 }

deleted src/context.rs

@@ -1,184 +0,0 @@

 use std::fmt::Display;
 use radicle::cob::issue::{Issue, IssueId};
 use radicle::cob::patch::{Patch, PatchId};
 use radicle::crypto::ssh::keystore::{Keystore, MemorySigner};
 use radicle::crypto::Signer;
 use radicle::identity::{Project, RepoId};
 use radicle::node::notifications::Notification;
 use radicle::profile::env::RAD_PASSPHRASE;
 use radicle::storage::git::Repository;
 use radicle::storage::{ReadRepository, ReadStorage};
 use radicle::Profile;
 use radicle_term as term;
 use term::{passphrase, spinner, Passphrase};
 use inquire::validator;
 use crate::cob::inbox;
 /// Git revision parameter. Supports extended SHA-1 syntax.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Rev(String);
 impl From<String> for Rev {
     fn from(value: String) -> Self {
         Rev(value)
     }
 }
 impl Display for Rev {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.0)
     }
 }
 /// Application context that holds all the project data that are
 /// needed to render it.
 pub struct Context {
     profile: Profile,
     rid: RepoId,
     project: Project,
     repository: Repository,
     issues: Option<Vec<(IssueId, Issue)>>,
     patches: Option<Vec<(PatchId, Patch)>>,
     notifications: Vec<Notification>,
     signer: Option<Box<dyn Signer>>,
 }
 impl Context {
     pub fn new(profile: Profile, rid: RepoId) -> Result<Self, anyhow::Error> {
         let repository = profile.storage.repository(rid).unwrap();
         let project = repository.identity_doc()?.project()?;
         let notifications = inbox::all(&repository, &profile)?;
         let issues = None;
         let patches = None;
         let signer = None;
         Ok(Self {
             profile,
             rid,
             project,
             repository,
             issues,
             patches,
             notifications,
             signer,
         })
     }
     pub fn with_issues(mut self) -> Self {
         use crate::cob::issue;
         self.issues = Some(issue::all(&self.repository).unwrap_or_default());
         self
     }
     pub fn with_patches(mut self) -> Self {
         use crate::cob::patch;
         self.patches = Some(patch::all(&self.repository).unwrap_or_default());
         self
     }
     pub fn with_signer(mut self) -> Self {
         self.signer = signer(&self.profile).ok();
         self
     }
     pub fn profile(&self) -> &Profile {
         &self.profile
     }
     pub fn rid(&self) -> &RepoId {
         &self.rid
     }
     pub fn project(&self) -> &Project {
         &self.project
     }
     pub fn repository(&self) -> &Repository {
         &self.repository
     }
     pub fn issues(&self) -> &Option<Vec<(IssueId, Issue)>> {
         &self.issues
     }
     pub fn patches(&self) -> &Option<Vec<(PatchId, Patch)>> {
         &self.patches
     }
     pub fn notifications(&self) -> &Vec<Notification> {
         &self.notifications
     }
     #[allow(clippy::borrowed_box)]
     pub fn signer(&self) -> &Option<Box<dyn Signer>> {
         &self.signer
     }
     pub fn reload_patches(&mut self) {
         use crate::cob::patch;
         self.patches = Some(patch::all(&self.repository).unwrap_or_default());
     }
     pub fn reload_issues(&mut self) {
         use crate::cob::issue;
         self.issues = Some(issue::all(&self.repository).unwrap_or_default());
     }
 }
 /// Validates secret key passphrases.
 #[derive(Clone)]
 pub struct PassphraseValidator {
     keystore: Keystore,
 }
 impl PassphraseValidator {
     /// Create a new validator.
     pub fn new(keystore: Keystore) -> Self {
         Self { keystore }
     }
 }
 impl inquire::validator::StringValidator for PassphraseValidator {
     fn validate(
         &self,
         input: &str,
     ) -> Result<validator::Validation, inquire::error::CustomUserError> {
         let passphrase = Passphrase::from(input.to_owned());
         if self.keystore.is_valid_passphrase(&passphrase)? {
             Ok(validator::Validation::Valid)
         } else {
             Ok(validator::Validation::Invalid(
                 validator::ErrorMessage::from("Invalid passphrase, please try again"),
             ))
         }
     }
 }
 /// Get the signer. First we try getting it from ssh-agent, otherwise we prompt the user,
 /// if we're connected to a TTY.
 pub fn signer(profile: &Profile) -> anyhow::Result<Box<dyn Signer>> {
     if let Ok(signer) = profile.signer() {
         return Ok(signer);
     }
     let validator = PassphraseValidator::new(profile.keystore.clone());
     let passphrase = match passphrase(validator) {
         Ok(p) => p,
         Err(inquire::InquireError::NotTTY) => {
             return Err(anyhow::anyhow!(
                 "running in non-interactive mode, please set `{RAD_PASSPHRASE}` to unseal your key",
             ));
         }
         Err(e) => return Err(e.into()),
     };
     let spinner = spinner("Unsealing key...");
     let signer = MemorySigner::load(&profile.keystore, Some(passphrase))?;
     spinner.finish();
     Ok(signer.boxed())
 }

modified src/lib.rs

@@ -1,53 +1,19 @@

 use std::fmt::Display;
 use std::hash::Hash;
 use std::time::Duration;
 use anyhow::Result;
 use serde::ser::{Serialize, SerializeStruct, Serializer};
 use tuirealm::terminal::TerminalBridge;
 use tuirealm::tui::layout::Rect;
 use tuirealm::Frame;
 use tuirealm::{Application, EventListenerCfg, NoUserEvent};
 use radicle::cob::ObjectId;
 use radicle::node::notifications::NotificationId;
 pub mod cob;
 pub mod context;
 pub mod log;
 pub mod ui;
 pub mod flux;
 use context::Context;
 use ui::theme::Theme;
 pub mod common;
 /// Trait that must be implemented by client applications in order to be run
 /// as tui-application using tui-realm. Implementors act as models to the
 /// tui-realm application that can be polled for new messages, updated
 /// accordingly and rendered with new state.
 ///
 /// Please see `examples/` for further information on how to use it.
 pub trait Tui<Id, Message, Return>
 where
     Id: Eq + PartialEq + Clone + Hash,
     Message: Eq,
 {
     /// Should initialize an application by mounting and activating components.
     fn init(&mut self, app: &mut Application<Id, Message, NoUserEvent>) -> Result<()>;
 #[cfg(feature = "realm")]
 pub mod realm;
     /// Should update the current state by handling a message from the view. Returns true
     /// if view should be updated (e.g. a message was received and the current state changed).
     fn update(&mut self, app: &mut Application<Id, Message, NoUserEvent>) -> Result<bool>;
     /// Should draw the application to a frame.
     fn view(&mut self, app: &mut Application<Id, Message, NoUserEvent>, frame: &mut Frame);
     /// Should return `Some` if the application is requested to quit.
     fn exit(&self) -> Option<Exit<Return>>;
 }
 #[cfg(feature = "flux")]
 pub mod flux;
 /// An optional return value.
 pub struct Exit<T> {

@@ -118,174 +84,3 @@ impl Serialize for SelectionExit {

         state.end()
     }
 }
 /// A tui-window using the cross-platform Terminal helper provided
 /// by tui-realm.
 pub struct Window {
     /// Helper around `Terminal` to quickly setup and perform on terminal.
     pub terminal: TerminalBridge,
 }
 impl Default for Window {
     fn default() -> Self {
         Self::new()
     }
 }
 /// Provides a way to create and run a new tui-application.
 impl Window {
     /// Creates a tui-window using the default cross-platform Terminal
     /// helper and panics if its creation fails.
     pub fn new() -> Self {
         let terminal = TerminalBridge::new().expect("Cannot create terminal bridge");
         Self { terminal }
     }
     /// Runs this tui-window with the tui-application given and performs the
     /// following steps:
     /// 1. Enter alternative terminal screen
     /// 2. Run main loop until application should quit and with each iteration
     ///    - poll new events (tick or user event)
     ///    - update application state
     ///    - redraw view
     /// 3. Leave alternative terminal screen
     pub fn run<T, Id, Message, Return>(
         &mut self,
         tui: &mut T,
         interval: u64,
     ) -> Result<Option<Return>>
     where
         T: Tui<Id, Message, Return>,
         Id: Eq + PartialEq + Clone + Hash,
         Message: Eq,
     {
         let mut update = true;
         let mut resize = false;
         let mut size = Rect::default();
         let mut app = Application::init(
             EventListenerCfg::default().default_input_listener(Duration::from_millis(interval)),
         );
         tui.init(&mut app)?;
         while tui.exit().is_none() {
             if update || resize {
                 self.terminal
                     .raw_mut()
                     .draw(|frame| tui.view(&mut app, frame))?;
             }
             update = tui.update(&mut app)?;
             resize = size != self.terminal.raw_mut().size()?;
             size = self.terminal.raw_mut().size()?;
         }
         Ok(tui.exit().unwrap().value)
     }
 }
 /// `tuirealm`'s event and prop system is designed to work with flat component hierarchies.
 /// Building deep nested component hierarchies would need a lot more additional effort to
 /// properly pass events and props down these hierarchies. This makes it hard to implement
 /// full app views (home, patch details etc) as components.
 ///
 /// View pages take into account these flat component hierarchies, and provide
 /// switchable sets of components.
 pub trait ViewPage<Id, Message>
 where
     Id: Eq + PartialEq + Clone + Hash,
     Message: Eq,
 {
     /// Will be called whenever a view page is pushed onto the page stack. Should create and mount all widgets.
     fn mount(
         &mut self,
         app: &mut Application<Id, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()>;
     /// Will be called whenever a view page is popped from the page stack. Should unmount all widgets.
     fn unmount(&self, app: &mut Application<Id, Message, NoUserEvent>) -> Result<()>;
     /// Will be called whenever a view page is on top of the stack and can be used to update its internal
     /// state depending on the message passed.
     fn update(
         &mut self,
         app: &mut Application<Id, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         message: Message,
     ) -> Result<Option<Message>>;
     /// Will be called whenever a view page is on top of the page stack and needs to be rendered.
     fn view(&mut self, app: &mut Application<Id, Message, NoUserEvent>, frame: &mut Frame);
     /// Will be called whenever this view page is pushed to the stack, or it is on top of the stack again
     /// after another view page was popped from the stack.
     fn subscribe(&self, app: &mut Application<Id, Message, NoUserEvent>) -> Result<()>;
     /// Will be called whenever this view page is on top of the stack and another view page is pushed
     /// to the stack, or if this is popped from the stack.
     fn unsubscribe(&self, app: &mut Application<Id, Message, NoUserEvent>) -> Result<()>;
 }
 /// View pages need to preserve their state (e.g. selected navigation tab, contents
 /// and the selected row of a table). Therefor they should not be (re-)created
 /// each time they are displayed.
 /// Instead the application can push a new page onto the page stack if it needs to
 /// be displayed. Its components are then created using the internal state. If a
 /// new page needs to be displayed, it will also be pushed onto the stack. Leaving
 /// that page again will pop it from the stack. The application can then return to
 /// the previously displayed page in the state it was left.
 #[derive(Default)]
 pub struct PageStack<Id, Message>
 where
     Id: Eq + PartialEq + Clone + Hash,
     Message: Eq,
 {
     pages: Vec<Box<dyn ViewPage<Id, Message>>>,
 }
 impl<Id, Message> PageStack<Id, Message>
 where
     Id: Eq + PartialEq + Clone + Hash,
     Message: Eq,
 {
     pub fn push(
         &mut self,
         mut page: Box<dyn ViewPage<Id, Message>>,
         app: &mut Application<Id, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         if let Some(page) = self.pages.last() {
             page.unsubscribe(app)?;
         }
         page.mount(app, context, theme)?;
         page.subscribe(app)?;
         self.pages.push(page);
         Ok(())
     }
     pub fn pop(&mut self, app: &mut Application<Id, Message, NoUserEvent>) -> Result<()> {
         self.peek_mut()?.unsubscribe(app)?;
         self.peek_mut()?.unmount(app)?;
         self.pages.pop();
         self.peek_mut()?.subscribe(app)?;
         Ok(())
     }
     pub fn peek_mut(&mut self) -> Result<&mut Box<dyn ViewPage<Id, Message>>> {
         match self.pages.last_mut() {
             Some(page) => Ok(page),
             None => Err(anyhow::anyhow!(
                 "Could not peek active page. Page stack is empty."
             )),
         }
     }
 }

deleted src/log.rs

@@ -1,15 +0,0 @@

 use log::LevelFilter;
 use radicle::profile::Profile;
 pub fn enable(profile: &Profile, cmd: &str, op: &str) -> Result<(), anyhow::Error> {
     let logfile = format!(
         "{}/rad-tui-{}-{}.log",
         profile.home().path().to_string_lossy(),
         cmd,
         op,
     );
     simple_logging::log_to_file(logfile, LevelFilter::Info)?;
     Ok(())
 }

added src/realm.rs

@@ -0,0 +1,211 @@

 pub mod ui;
 use std::hash::Hash;
 use std::time::Duration;
 use anyhow::Result;
 use tuirealm::terminal::TerminalBridge;
 use tuirealm::tui::layout::Rect;
 use tuirealm::Frame;
 use tuirealm::{Application, EventListenerCfg, NoUserEvent};
 use crate::common::context::Context;
 use crate::Exit;
 use ui::theme::Theme;
 /// Trait that must be implemented by client applications in order to be run
 /// as tui-application using tui-realm. Implementors act as models to the
 /// tui-realm application that can be polled for new messages, updated
 /// accordingly and rendered with new state.
 ///
 /// Please see `examples/` for further information on how to use it.
 pub trait Tui<Id, Message, Return>
 where
     Id: Eq + PartialEq + Clone + Hash,
     Message: Eq,
 {
     /// Should initialize an application by mounting and activating components.
     fn init(&mut self, app: &mut Application<Id, Message, NoUserEvent>) -> Result<()>;
     /// Should update the current state by handling a message from the view. Returns true
     /// if view should be updated (e.g. a message was received and the current state changed).
     fn update(&mut self, app: &mut Application<Id, Message, NoUserEvent>) -> Result<bool>;
     /// Should draw the application to a frame.
     fn view(&mut self, app: &mut Application<Id, Message, NoUserEvent>, frame: &mut Frame);
     /// Should return `Some` if the application is requested to quit.
     fn exit(&self) -> Option<Exit<Return>>;
 }
 /// A tui-window using the cross-platform Terminal helper provided
 /// by tui-realm.
 pub struct Window {
     /// Helper around `Terminal` to quickly setup and perform on terminal.
     pub terminal: TerminalBridge,
 }
 impl Default for Window {
     fn default() -> Self {
         Self::new()
     }
 }
 /// Provides a way to create and run a new tui-application.
 impl Window {
     /// Creates a tui-window using the default cross-platform Terminal
     /// helper and panics if its creation fails.
     pub fn new() -> Self {
         let terminal = TerminalBridge::new().expect("Cannot create terminal bridge");
         Self { terminal }
     }
     /// Runs this tui-window with the tui-application given and performs the
     /// following steps:
     /// 1. Enter alternative terminal screen
     /// 2. Run main loop until application should quit and with each iteration
     ///    - poll new events (tick or user event)
     ///    - update application state
     ///    - redraw view
     /// 3. Leave alternative terminal screen
     pub fn run<T, Id, Message, Return>(
         &mut self,
         tui: &mut T,
         interval: u64,
     ) -> Result<Option<Return>>
     where
         T: Tui<Id, Message, Return>,
         Id: Eq + PartialEq + Clone + Hash,
         Message: Eq,
     {
         let mut update = true;
         let mut resize = false;
         let mut size = Rect::default();
         let mut app = Application::init(
             EventListenerCfg::default().default_input_listener(Duration::from_millis(interval)),
         );
         tui.init(&mut app)?;
         while tui.exit().is_none() {
             if update || resize {
                 self.terminal
                     .raw_mut()
                     .draw(|frame| tui.view(&mut app, frame))?;
             }
             update = tui.update(&mut app)?;
             resize = size != self.terminal.raw_mut().size()?;
             size = self.terminal.raw_mut().size()?;
         }
         Ok(tui.exit().unwrap().value)
     }
 }
 /// `tuirealm`'s event and prop system is designed to work with flat component hierarchies.
 /// Building deep nested component hierarchies would need a lot more additional effort to
 /// properly pass events and props down these hierarchies. This makes it hard to implement
 /// full app views (home, patch details etc) as components.
 ///
 /// View pages take into account these flat component hierarchies, and provide
 /// switchable sets of components.
 pub trait ViewPage<Id, Message>
 where
     Id: Eq + PartialEq + Clone + Hash,
     Message: Eq,
 {
     /// Will be called whenever a view page is pushed onto the page stack. Should create and mount all widgets.
     fn mount(
         &mut self,
         app: &mut Application<Id, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()>;
     /// Will be called whenever a view page is popped from the page stack. Should unmount all widgets.
     fn unmount(&self, app: &mut Application<Id, Message, NoUserEvent>) -> Result<()>;
     /// Will be called whenever a view page is on top of the stack and can be used to update its internal
     /// state depending on the message passed.
     fn update(
         &mut self,
         app: &mut Application<Id, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
         message: Message,
     ) -> Result<Option<Message>>;
     /// Will be called whenever a view page is on top of the page stack and needs to be rendered.
     fn view(&mut self, app: &mut Application<Id, Message, NoUserEvent>, frame: &mut Frame);
     /// Will be called whenever this view page is pushed to the stack, or it is on top of the stack again
     /// after another view page was popped from the stack.
     fn subscribe(&self, app: &mut Application<Id, Message, NoUserEvent>) -> Result<()>;
     /// Will be called whenever this view page is on top of the stack and another view page is pushed
     /// to the stack, or if this is popped from the stack.
     fn unsubscribe(&self, app: &mut Application<Id, Message, NoUserEvent>) -> Result<()>;
 }
 /// View pages need to preserve their state (e.g. selected navigation tab, contents
 /// and the selected row of a table). Therefor they should not be (re-)created
 /// each time they are displayed.
 /// Instead the application can push a new page onto the page stack if it needs to
 /// be displayed. Its components are then created using the internal state. If a
 /// new page needs to be displayed, it will also be pushed onto the stack. Leaving
 /// that page again will pop it from the stack. The application can then return to
 /// the previously displayed page in the state it was left.
 #[derive(Default)]
 pub struct PageStack<Id, Message>
 where
     Id: Eq + PartialEq + Clone + Hash,
     Message: Eq,
 {
     pages: Vec<Box<dyn ViewPage<Id, Message>>>,
 }
 impl<Id, Message> PageStack<Id, Message>
 where
     Id: Eq + PartialEq + Clone + Hash,
     Message: Eq,
 {
     pub fn push(
         &mut self,
         mut page: Box<dyn ViewPage<Id, Message>>,
         app: &mut Application<Id, Message, NoUserEvent>,
         context: &Context,
         theme: &Theme,
     ) -> Result<()> {
         if let Some(page) = self.pages.last() {
             page.unsubscribe(app)?;
         }
         page.mount(app, context, theme)?;
         page.subscribe(app)?;
         self.pages.push(page);
         Ok(())
     }
     pub fn pop(&mut self, app: &mut Application<Id, Message, NoUserEvent>) -> Result<()> {
         self.peek_mut()?.unsubscribe(app)?;
         self.peek_mut()?.unmount(app)?;
         self.pages.pop();
         self.peek_mut()?.subscribe(app)?;
         Ok(())
     }
     pub fn peek_mut(&mut self) -> Result<&mut Box<dyn ViewPage<Id, Message>>> {
         match self.pages.last_mut() {
             Some(page) => Ok(page),
             None => Err(anyhow::anyhow!(
                 "Could not peek active page. Page stack is empty."
             )),
         }
     }
 }

added src/realm/ui.rs

@@ -0,0 +1,164 @@

 pub mod cob;
 pub mod ext;
 pub mod layout;
 pub mod state;
 pub mod subscription;
 pub mod theme;
 pub mod widget;
 use tuirealm::props::{AttrValue, Attribute};
 use tuirealm::MockComponent;
 use widget::container::{
     AppHeader, AppInfo, Container, GlobalListener, Header, LabeledContainer, Popup, Tabs,
     VerticalLine,
 };
 use widget::context::{Shortcut, Shortcuts};
 use widget::label::{self, Label, Textarea};
 use widget::list::{ColumnWidth, Property, PropertyList, PropertyTable};
 use widget::Widget;
 use theme::{style, Theme};
 use crate::common::context::Context;
 pub fn global_listener() -> Widget<GlobalListener> {
     Widget::new(GlobalListener::default())
 }
 pub fn container_header(theme: &Theme, label: Widget<Label>) -> Widget<Header<1>> {
     let header = Header::new([label], [ColumnWidth::Grow], theme.clone());
     Widget::new(header)
 }
 pub fn container(theme: &Theme, component: Box<dyn MockComponent>) -> Widget<Container> {
     let container = Container::new(component, theme.clone());
     Widget::new(container)
 }
 pub fn labeled_container(
     theme: &Theme,
     title: &str,
     component: Box<dyn MockComponent>,
 ) -> Widget<LabeledContainer> {
     let header = container_header(theme, label::header(&format!(" {title} ")));
     let container = LabeledContainer::new(header, component, theme.clone());
     Widget::new(container)
 }
 pub fn shortcut(theme: &Theme, short: &str, long: &str) -> Widget<Shortcut> {
     let short = label::default(short).style(style::gray());
     let long = label::default(long).style(style::gray_dim());
     let divider = label::default(&theme.icons.whitespace.to_string());
     // TODO: Remove when size constraints are implemented
     let short_w = short.query(Attribute::Width).unwrap().unwrap_size();
     let divider_w = divider.query(Attribute::Width).unwrap().unwrap_size();
     let long_w = long.query(Attribute::Width).unwrap().unwrap_size();
     let width = short_w.saturating_add(divider_w).saturating_add(long_w);
     let shortcut = Shortcut::new(short, divider, long);
     Widget::new(shortcut).height(1).width(width)
 }
 pub fn shortcuts(theme: &Theme, shortcuts: Vec<Widget<Shortcut>>) -> Widget<Shortcuts> {
     let divider =
         label::default(&format!(" {} ", theme.icons.shortcutbar_divider)).style(style::gray_dim());
     let shortcut_bar = Shortcuts::new(shortcuts, divider);
     Widget::new(shortcut_bar).height(1)
 }
 pub fn property(theme: &Theme, name: &str, value: &str) -> Widget<Property> {
     let name = label::property(name);
     let divider = label::default(&format!(" {} ", theme.icons.property_divider));
     let value = label::default(value);
     // TODO: Remove when size constraints are implemented
     let name_w = name.query(Attribute::Width).unwrap().unwrap_size();
     let divider_w = divider.query(Attribute::Width).unwrap().unwrap_size();
     let value_w = value.query(Attribute::Width).unwrap().unwrap_size();
     let width = name_w.saturating_add(divider_w).saturating_add(value_w);
     let property = Property::new(name, value).with_divider(divider);
     Widget::new(property).height(1).width(width)
 }
 pub fn property_list(_theme: &Theme, properties: Vec<Widget<Property>>) -> Widget<PropertyList> {
     let property_list = PropertyList::new(properties);
     Widget::new(property_list)
 }
 pub fn property_table(_theme: &Theme, properties: Vec<Widget<Property>>) -> Widget<PropertyTable> {
     let table = PropertyTable::new(properties);
     Widget::new(table)
 }
 pub fn tabs(_theme: &Theme, tabs: Vec<Widget<Label>>) -> Widget<Tabs> {
     let tabs = Tabs::new(tabs);
     Widget::new(tabs).height(2)
 }
 pub fn app_info(context: &Context) -> Widget<AppInfo> {
     let project = label::default(context.project().name()).style(style::cyan());
     let rid = label::default(&format!(" ({})", context.rid())).style(style::yellow());
     let project_w = project
         .query(Attribute::Width)
         .unwrap_or(AttrValue::Size(0))
         .unwrap_size();
     let rid_w = rid
         .query(Attribute::Width)
         .unwrap_or(AttrValue::Size(0))
         .unwrap_size();
     let info = AppInfo::new(project, rid);
     Widget::new(info).width(project_w.saturating_add(rid_w))
 }
 pub fn app_header(
     context: &Context,
     theme: &Theme,
     nav: Option<Widget<Tabs>>,
 ) -> Widget<AppHeader> {
     let line = label::default(&theme.icons.tab_overline.to_string()).style(style::magenta());
     let line = Widget::new(VerticalLine::new(line));
     let info = app_info(context);
     let header = AppHeader::new(nav, info, line);
     Widget::new(header)
 }
 pub fn info(theme: &Theme, message: &str) -> Widget<Popup> {
     let textarea = Widget::new(Textarea::default()).content(AttrValue::String(message.to_owned()));
     let container = labeled_container(theme, "Info", textarea.to_boxed());
     Widget::new(Popup::new(theme.clone(), container))
         .width(50)
         .height(20)
 }
 pub fn warning(theme: &Theme, message: &str) -> Widget<Popup> {
     let textarea = Widget::new(Textarea::default()).content(AttrValue::String(message.to_owned()));
     let container = labeled_container(theme, "Warning", textarea.to_boxed());
     Widget::new(Popup::new(theme.clone(), container))
         .width(50)
         .height(20)
 }
 pub fn error(theme: &Theme, message: &str) -> Widget<Popup> {
     let textarea = Widget::new(Textarea::default()).content(AttrValue::String(message.to_owned()));
     let container = labeled_container(theme, "Error", textarea.to_boxed());
     Widget::new(Popup::new(theme.clone(), container))
         .width(50)
         .height(20)
 }

added src/realm/ui/cob.rs

@@ -0,0 +1,615 @@

 pub mod format;
 use anyhow::anyhow;
 use radicle_surf;
 use tuirealm::props::{Color, Style};
 use tuirealm::tui::text::Line;
 use tuirealm::tui::widgets::Cell;
 use radicle::cob::issue::{self, Issue, IssueId};
 use radicle::cob::patch::{self, Patch, PatchId};
 use radicle::cob::{Label, ObjectId, Timestamp};
 use radicle::issue::Issues;
 use radicle::node::notifications::{Notification, NotificationId, NotificationKind};
 use radicle::node::{Alias, AliasStore};
 use radicle::patch::Patches;
 use radicle::prelude::Did;
 use radicle::storage::git::Repository;
 use radicle::storage::{Oid, ReadRepository, RefUpdate};
 use radicle::{cob, Profile};
 use super::super::ui::theme::Theme;
 use super::super::ui::widget::list::{ListItem, TableItem};
 use super::widget::label;
 /// An author item that can be used in tables, list or trees.
 ///
 /// Breaks up dependencies to [`Profile`] and [`Repository`] that
 /// would be needed if [`AuthorItem`] would be used directly.
 #[derive(Clone)]
 pub struct AuthorItem {
     /// The author's DID.
     did: Did,
     /// The author's alias
     alias: Option<Alias>,
     /// True if the author is the current user.
     is_you: bool,
 }
 impl AuthorItem {
     pub fn did(&self) -> Did {
         self.did
     }
     pub fn is_you(&self) -> bool {
         self.is_you
     }
     pub fn alias(&self) -> Option<Alias> {
         self.alias.clone()
     }
 }
 /// A patch item that can be used in tables, list or trees.
 ///
 /// Breaks up dependencies to [`Profile`] and [`Repository`] that
 /// would be needed if [`Patch`] would be used directly.
 #[derive(Clone)]
 pub struct PatchItem {
     /// Patch OID.
     id: PatchId,
     /// Patch state.
     state: patch::State,
     /// Patch title.
     title: String,
     /// Author of the latest revision.
     author: AuthorItem,
     /// Head of the latest revision.
     head: Oid,
     /// Lines added by the latest revision.
     added: u16,
     /// Lines removed by the latest revision.
     removed: u16,
     /// Time when patch was opened.
     timestamp: Timestamp,
 }
 impl PatchItem {
     pub fn id(&self) -> &PatchId {
         &self.id
     }
     pub fn state(&self) -> &patch::State {
         &self.state
     }
     pub fn title(&self) -> &String {
         &self.title
     }
     pub fn author(&self) -> &AuthorItem {
         &self.author
     }
     pub fn head(&self) -> &Oid {
         &self.head
     }
     pub fn added(&self) -> u16 {
         self.added
     }
     pub fn removed(&self) -> u16 {
         self.removed
     }
     pub fn timestamp(&self) -> &Timestamp {
         &self.timestamp
     }
 }
 impl PartialEq for PatchItem {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
 }
 impl TryFrom<(&Profile, &Repository, PatchId, Patch)> for PatchItem {
     type Error = anyhow::Error;
     fn try_from(value: (&Profile, &Repository, PatchId, Patch)) -> Result<Self, Self::Error> {
         let (profile, repo, id, patch) = value;
         let (_, rev) = patch.latest();
         let repo = radicle_surf::Repository::open(repo.path())?;
         let base = repo.commit(rev.base())?;
         let head = repo.commit(rev.head())?;
         let diff = repo.diff(base.id, head.id)?;
         let author = patch.author().id;
         Ok(PatchItem {
             id,
             state: patch.state().clone(),
             title: patch.title().into(),
             author: AuthorItem {
                 did: author,
                 alias: profile.aliases().alias(&author),
                 is_you: *patch.author().id == *profile.did(),
             },
             head: rev.head(),
             added: diff.stats().insertions as u16,
             removed: diff.stats().deletions as u16,
             timestamp: rev.timestamp(),
         })
     }
 }
 impl TableItem<8> for PatchItem {
     fn row(&self, _theme: &Theme, highlight: bool) -> [Cell; 8] {
         let (icon, color) = format_patch_state(&self.state);
         if highlight {
             let state = label::reversed(&icon).into();
             let id = label::reversed(&format::cob(&self.id)).into();
             let title = label::reversed(&self.title.clone()).into();
             let author = label::reversed(&format_author(
                 &self.author.did,
                 &self.author.alias,
                 self.author.is_you,
             ))
             .into();
             let head = label::reversed(&format::oid(self.head)).into();
             let added = label::reversed(&format!("+{}", self.added)).into();
             let removed = label::reversed(&format!("-{}", self.removed)).into();
             let updated = label::reversed(&format::timestamp(&self.timestamp)).into();
             [state, id, title, author, head, added, removed, updated]
         } else {
             let state = label::default(&icon)
                 .style(Style::default().fg(color))
                 .into();
             let id = label::id(&format::cob(&self.id)).into();
             let title = label::default(&self.title.clone()).into();
             let author = match &self.author.alias {
                 Some(_) => label::alias(&format_author(
                     &self.author.did,
                     &self.author.alias,
                     self.author.is_you,
                 ))
                 .into(),
                 None => label::did(&format_author(
                     &self.author.did,
                     &self.author.alias,
                     self.author.is_you,
                 ))
                 .into(),
             };
             let head = label::oid(&format::oid(self.head)).into();
             let added = label::positive(&format!("+{}", self.added)).into();
             let removed = label::negative(&format!("-{}", self.removed)).into();
             let updated = label::timestamp(&format::timestamp(&self.timestamp)).into();
             [state, id, title, author, head, added, removed, updated]
         }
     }
 }
 /// An issue item that can be used in tables, list or trees.
 ///
 /// Breaks up dependencies to [`Profile`] and [`Repository`] that
 /// would be needed if [`Issue`] would be used directly.
 #[derive(Clone)]
 pub struct IssueItem {
     /// Issue OID.
     id: IssueId,
     /// Issue state.
     state: issue::State,
     /// Issue title.
     title: String,
     /// Issue author.
     author: AuthorItem,
     /// Issue labels.
     labels: Vec<Label>,
     /// Issue assignees.
     assignees: Vec<AuthorItem>,
     /// Time when issue was opened.
     timestamp: Timestamp,
 }
 impl IssueItem {
     pub fn id(&self) -> &IssueId {
         &self.id
     }
     pub fn state(&self) -> &issue::State {
         &self.state
     }
     pub fn title(&self) -> &String {
         &self.title
     }
     pub fn author(&self) -> &AuthorItem {
         &self.author
     }
     pub fn labels(&self) -> &Vec<Label> {
         &self.labels
     }
     pub fn assignees(&self) -> &Vec<AuthorItem> {
         &self.assignees
     }
     pub fn timestamp(&self) -> &Timestamp {
         &self.timestamp
     }
 }
 impl From<(&Profile, &Repository, IssueId, Issue)> for IssueItem {
     fn from(value: (&Profile, &Repository, IssueId, Issue)) -> Self {
         let (profile, _, id, issue) = value;
         let author = issue.author().id;
         IssueItem {
             id,
             state: *issue.state(),
             title: issue.title().into(),
             author: AuthorItem {
                 did: issue.author().id,
                 alias: profile.aliases().alias(&author),
                 is_you: *issue.author().id == *profile.did(),
             },
             labels: issue.labels().cloned().collect(),
             assignees: issue
                 .assignees()
                 .map(|did| AuthorItem {
                     did: *did,
                     alias: profile.aliases().alias(did),
                     is_you: *did == profile.did(),
                 })
                 .collect::<Vec<_>>(),
             timestamp: issue.timestamp(),
         }
     }
 }
 impl TableItem<7> for IssueItem {
     fn row(&self, _theme: &Theme, highlight: bool) -> [Cell; 7] {
         let (icon, color) = format_issue_state(&self.state);
         if highlight {
             let state = label::reversed(&icon).into();
             let id = label::reversed(&format::cob(&self.id)).into();
             let title = label::reversed(&self.title.clone()).into();
             let author = label::reversed(&format_author(
                 &self.author.did,
                 &self.author.alias,
                 self.author.is_you,
             ))
             .into();
             let labels = label::reversed(&format_labels(&self.labels)).into();
             let assignees = self
                 .assignees
                 .iter()
                 .map(|author| (author.did, author.alias.clone(), author.is_you))
                 .collect::<Vec<_>>();
             let assignees = label::reversed(&format_assignees(&assignees)).into();
             let opened = label::reversed(&format::timestamp(&self.timestamp)).into();
             [state, id, title, author, labels, assignees, opened]
         } else {
             let state = label::default(&icon)
                 .style(Style::default().fg(color))
                 .into();
             let id = label::id(&format::cob(&self.id)).into();
             let title = label::default(&self.title.clone()).into();
             let author = match &self.author.alias {
                 Some(_) => label::alias(&format_author(
                     &self.author.did,
                     &self.author.alias,
                     self.author.is_you,
                 ))
                 .into(),
                 None => label::did(&format_author(
                     &self.author.did,
                     &self.author.alias,
                     self.author.is_you,
                 ))
                 .into(),
             };
             let labels = label::labels(&format_labels(&self.labels)).into();
             let assignees = self
                 .assignees
                 .iter()
                 .map(|author| (author.did, author.alias.clone(), author.is_you))
                 .collect::<Vec<_>>();
             let assignees = label::did(&format_assignees(&assignees)).into();
             let opened = label::timestamp(&format::timestamp(&self.timestamp)).into();
             [state, id, title, author, labels, assignees, opened]
         }
     }
 }
 impl ListItem for IssueItem {
     fn row(&self, theme: &Theme) -> tuirealm::tui::widgets::ListItem {
         let (state, state_color) = format_issue_state(&self.state);
         let lines = vec![
             Line::from(vec![
                 label::default(&state)
                     .style(Style::default().fg(state_color))
                     .into(),
                 label::title(&self.title).into(),
             ]),
             Line::from(vec![
                 label::default("   ").into(),
                 match &self.author.alias {
                     Some(_) => label::alias(&format_author(
                         &self.author.did,
                         &self.author.alias,
                         self.author.is_you,
                     ))
                     .into(),
                     None => label::did(&format_author(
                         &self.author.did,
                         &self.author.alias,
                         self.author.is_you,
                     ))
                     .into(),
                 },
                 label::property_divider(&format!(" {} ", theme.icons.property_divider)).into(),
                 label::timestamp(&format::timestamp(&self.timestamp)).into(),
             ]),
         ];
         tuirealm::tui::widgets::ListItem::new(lines)
     }
 }
 impl PartialEq for IssueItem {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
 }
 //////////////////////////////////////////////////////
 #[derive(Clone)]
 pub enum NotificationKindItem {
     Branch {
         name: String,
         summary: String,
         status: String,
         id: Option<ObjectId>,
     },
     Cob {
         type_name: String,
         summary: String,
         status: String,
         id: Option<ObjectId>,
     },
 }
 impl TryFrom<(&Repository, NotificationKind, RefUpdate)> for NotificationKindItem {
     type Error = anyhow::Error;
     fn try_from(value: (&Repository, NotificationKind, RefUpdate)) -> Result<Self, Self::Error> {
         let (repo, kind, update) = value;
         let issues = Issues::open(repo)?;
         let patches = Patches::open(repo)?;
         match kind {
             NotificationKind::Branch { name } => {
                 let (head, message) = if let Some(head) = update.new() {
                     let message = repo.commit(head)?.summary().unwrap_or_default().to_owned();
                     (Some(head), message)
                 } else {
                     (None, String::new())
                 };
                 let status = match update {
                     RefUpdate::Updated { .. } => "updated",
                     RefUpdate::Created { .. } => "created",
                     RefUpdate::Deleted { .. } => "deleted",
                     RefUpdate::Skipped { .. } => "skipped",
                 };
                 Ok(NotificationKindItem::Branch {
                     name: name.to_string(),
                     summary: message,
                     status: status.to_string(),
                     id: head.map(ObjectId::from),
                 })
             }
             NotificationKind::Cob { type_name, id } => {
                 let (category, summary) = if type_name == *cob::issue::TYPENAME {
                     let issue = issues.get(&id)?.ok_or(anyhow!("missing"))?;
                     (String::from("issue"), issue.title().to_owned())
                 } else if type_name == *cob::patch::TYPENAME {
                     let patch = patches.get(&id)?.ok_or(anyhow!("missing"))?;
                     (String::from("patch"), patch.title().to_owned())
                 } else {
                     (type_name.to_string(), "".to_owned())
                 };
                 let status = match update {
                     RefUpdate::Updated { .. } => "updated",
                     RefUpdate::Created { .. } => "opened",
                     RefUpdate::Deleted { .. } => "deleted",
                     RefUpdate::Skipped { .. } => "skipped",
                 };
                 Ok(NotificationKindItem::Cob {
                     type_name: category.to_string(),
                     summary: summary.to_string(),
                     status: status.to_string(),
                     id: Some(id),
                 })
             }
         }
     }
 }
 #[derive(Clone)]
 pub struct NotificationItem {
     /// Unique notification ID.
     pub id: NotificationId,
     /// Mark this notification as seen.
     pub seen: bool,
     /// Wrapped notification kind.
     pub kind: NotificationKindItem,
     /// Time the update has happened.
     timestamp: Timestamp,
 }
 impl NotificationItem {
     pub fn id(&self) -> &NotificationId {
         &self.id
     }
     pub fn seen(&self) -> bool {
         self.seen
     }
     pub fn kind(&self) -> &NotificationKindItem {
         &self.kind
     }
     pub fn timestamp(&self) -> &Timestamp {
         &self.timestamp
     }
 }
 impl TableItem<7> for NotificationItem {
     fn row(&self, _theme: &Theme, highlight: bool) -> [Cell; 7] {
         let seen = if self.seen {
             label::blank()
         } else {
             label::positive(" ● ")
         };
         let (type_name, summary, status, id) = match &self.kind() {
             NotificationKindItem::Branch {
                 name,
                 summary,
                 status,
                 id: _,
             } => ("branch".to_string(), summary, status, name.to_string()),
             NotificationKindItem::Cob {
                 type_name,
                 summary,
                 status,
                 id,
             } => {
                 let id = id.map(|id| format::cob(&id)).unwrap_or_default();
                 (type_name.to_string(), summary, status, id.to_string())
             }
         };
         let timestamp = if highlight {
             label::reversed(&format::timestamp(&self.timestamp))
         } else {
             label::timestamp(&format::timestamp(&self.timestamp))
         };
         [
             label::default(&format!(" {}", &self.id)).into(),
             seen.into(),
             label::alias(&type_name).into(),
             label::default(summary).into(),
             label::id(&id).into(),
             label::default(status).into(),
             timestamp.into(),
         ]
     }
 }
 impl TryFrom<(&Repository, Notification)> for NotificationItem {
     type Error = anyhow::Error;
     fn try_from(value: (&Repository, Notification)) -> Result<Self, Self::Error> {
         let (repo, notification) = value;
         let kind = NotificationKindItem::try_from((repo, notification.kind, notification.update))?;
         Ok(NotificationItem {
             id: notification.id,
             seen: notification.status.is_read(),
             kind,
             timestamp: notification.timestamp.into(),
         })
     }
 }
 impl PartialEq for NotificationItem {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
 }
 pub fn format_patch_state(state: &patch::State) -> (String, Color) {
     match state {
         patch::State::Open { conflicts: _ } => (" ● ".into(), Color::Green),
         patch::State::Archived => (" ● ".into(), Color::Yellow),
         patch::State::Draft => (" ● ".into(), Color::Gray),
         patch::State::Merged {
             revision: _,
             commit: _,
         } => (" ● ".into(), Color::Cyan),
     }
 }
 pub fn format_author(did: &Did, alias: &Option<Alias>, is_you: bool) -> String {
     let author = match alias {
         Some(alias) => format!("{alias}"),
         None => format::did(did),
     };
     if is_you {
         format!("{} (you)", author)
     } else {
         author
     }
 }
 pub fn format_issue_state(state: &issue::State) -> (String, Color) {
     match state {
         issue::State::Open => (" ● ".into(), Color::Green),
         issue::State::Closed { reason: _ } => (" ● ".into(), Color::Red),
     }
 }
 pub fn format_labels(labels: &[Label]) -> String {
     let mut output = String::new();
     let mut labels = labels.iter().peekable();
     while let Some(label) = labels.next() {
         output.push_str(&label.to_string());
         if labels.peek().is_some() {
             output.push(',');
         }
     }
     output
 }
 pub fn format_assignees(assignees: &[(Did, Option<Alias>, bool)]) -> String {
     let mut output = String::new();
     let mut assignees = assignees.iter().peekable();
     while let Some((assignee, alias, is_you)) = assignees.next() {
         output.push_str(&format_author(assignee, alias, *is_you));
         if assignees.peek().is_some() {
             output.push(',');
         }
     }
     output
 }

added src/realm/ui/cob/format.rs

@@ -0,0 +1,27 @@

 use radicle::cob::{ObjectId, Timestamp};
 use radicle::prelude::Did;
 /// Format a git Oid.
 pub fn oid(oid: impl Into<radicle::git::Oid>) -> String {
     format!("{:.7}", oid.into())
 }
 /// Format a COB id.
 pub fn cob(id: &ObjectId) -> String {
     format!("{:.7}", id.to_string())
 }
 /// Format a DID.
 pub fn did(did: &Did) -> String {
     let nid = did.as_key().to_human();
     format!("{}…{}", &nid[..7], &nid[nid.len() - 7..])
 }
 /// Format a timestamp.
 pub fn timestamp(time: &Timestamp) -> String {
     let fmt = timeago::Formatter::new();
     let now = Timestamp::now();
     let duration = std::time::Duration::from_secs(now.as_secs() - time.as_secs());
     fmt.convert(duration)
 }

added src/realm/ui/ext.rs

@@ -0,0 +1,113 @@

 use tuirealm::tui::buffer::Buffer;
 use tuirealm::tui::layout::Rect;
 use tuirealm::tui::style::Style;
 use tuirealm::tui::widgets::{BorderType, Borders, Widget};
 pub struct HeaderBlock {
     /// Visible borders
     borders: Borders,
     /// Border style
     border_style: Style,
     /// Type of the border. The default is plain lines but one can choose to have rounded corners
     /// or doubled lines instead.
     border_type: BorderType,
     /// Widget style
     style: Style,
 }
 impl Default for HeaderBlock {
     fn default() -> HeaderBlock {
         HeaderBlock {
             borders: Borders::NONE,
             border_style: Default::default(),
             border_type: BorderType::Plain,
             style: Default::default(),
         }
     }
 }
 impl HeaderBlock {
     pub fn border_style(mut self, style: Style) -> HeaderBlock {
         self.border_style = style;
         self
     }
     pub fn style(mut self, style: Style) -> HeaderBlock {
         self.style = style;
         self
     }
     pub fn borders(mut self, flag: Borders) -> HeaderBlock {
         self.borders = flag;
         self
     }
     pub fn border_type(mut self, border_type: BorderType) -> HeaderBlock {
         self.border_type = border_type;
         self
     }
 }
 impl Widget for HeaderBlock {
     fn render(self, area: Rect, buf: &mut Buffer) {
         if area.area() == 0 {
             return;
         }
         buf.set_style(area, self.style);
         let symbols = BorderType::line_symbols(self.border_type);
         // Sides
         if self.borders.intersects(Borders::LEFT) {
             for y in area.top()..area.bottom() {
                 buf.get_mut(area.left(), y)
                     .set_symbol(symbols.vertical)
                     .set_style(self.border_style);
             }
         }
         if self.borders.intersects(Borders::TOP) {
             for x in area.left()..area.right() {
                 buf.get_mut(x, area.top())
                     .set_symbol(symbols.horizontal)
                     .set_style(self.border_style);
             }
         }
         if self.borders.intersects(Borders::RIGHT) {
             let x = area.right() - 1;
             for y in area.top()..area.bottom() {
                 buf.get_mut(x, y)
                     .set_symbol(symbols.vertical)
                     .set_style(self.border_style);
             }
         }
         if self.borders.intersects(Borders::BOTTOM) {
             let y = area.bottom() - 1;
             for x in area.left()..area.right() {
                 buf.get_mut(x, y)
                     .set_symbol(symbols.horizontal)
                     .set_style(self.border_style);
             }
         }
         // Corners
         if self.borders.contains(Borders::RIGHT | Borders::BOTTOM) {
             buf.get_mut(area.right() - 1, area.bottom() - 1)
                 .set_symbol(symbols.vertical_left)
                 .set_style(self.border_style);
         }
         if self.borders.contains(Borders::RIGHT | Borders::TOP) {
             buf.get_mut(area.right() - 1, area.top())
                 .set_symbol(symbols.top_right)
                 .set_style(self.border_style);
         }
         if self.borders.contains(Borders::LEFT | Borders::BOTTOM) {
             buf.get_mut(area.left(), area.bottom() - 1)
                 .set_symbol(symbols.vertical_right)
                 .set_style(self.border_style);
         }
         if self.borders.contains(Borders::LEFT | Borders::TOP) {
             buf.get_mut(area.left(), area.top())
                 .set_symbol(symbols.top_left)
                 .set_style(self.border_style);
         }
     }
 }

added src/realm/ui/layout.rs

@@ -0,0 +1,278 @@

 use tuirealm::props::{AttrValue, Attribute};
 use tuirealm::tui::layout::{Constraint, Direction, Layout, Rect};
 use tuirealm::MockComponent;
 pub struct AppHeader {
     pub nav: Rect,
     pub info: Rect,
     pub line: Rect,
 }
 pub struct FullPage {
     pub navigation: Rect,
     pub component: Rect,
     pub context: Rect,
     pub shortcuts: Rect,
 }
 pub struct DefaultPage {
     pub component: Rect,
     pub context: Rect,
     pub shortcuts: Rect,
 }
 pub struct IssuePage {
     pub header: Rect,
     pub left: Rect,
     pub right: Rect,
     pub context: Rect,
     pub shortcuts: Rect,
 }
 pub fn v_stack(
     widgets: Vec<Box<dyn MockComponent>>,
     area: Rect,
 ) -> Vec<(Box<dyn MockComponent>, Rect)> {
     let constraints = widgets
         .iter()
         .map(|w| {
             Constraint::Length(
                 w.query(Attribute::Height)
                     .unwrap_or(AttrValue::Size(0))
                     .unwrap_size(),
             )
         })
         .collect::<Vec<_>>();
     let layout = Layout::default()
         .direction(Direction::Vertical)
         .constraints(constraints)
         .split(area)
         .to_vec();
     widgets.into_iter().zip(layout).collect()
 }
 pub fn h_stack(
     widgets: Vec<Box<dyn MockComponent>>,
     area: Rect,
 ) -> Vec<(Box<dyn MockComponent>, Rect)> {
     let constraints = widgets
         .iter()
         .map(|w| {
             Constraint::Length(
                 w.query(Attribute::Width)
                     .unwrap_or(AttrValue::Size(0))
                     .unwrap_size(),
             )
         })
         .collect::<Vec<_>>();
     let layout = Layout::default()
         .direction(Direction::Horizontal)
         .constraints(constraints)
         .split(area)
         .to_vec();
     widgets.into_iter().zip(layout).collect()
 }
 pub fn app_header(area: Rect, info_w: u16) -> AppHeader {
     let nav_w = area.width.saturating_sub(info_w);
     let layout = Layout::default()
         .direction(Direction::Vertical)
         .constraints(vec![
             Constraint::Length(1),
             Constraint::Length(1),
             Constraint::Length(1),
         ])
         .split(area);
     let top = Layout::default()
         .direction(Direction::Horizontal)
         .constraints([Constraint::Length(nav_w), Constraint::Length(info_w)].as_ref())
         .split(layout[1]);
     AppHeader {
         nav: top[0],
         info: top[1],
         line: layout[2],
     }
 }
 pub fn full_page(area: Rect, context_h: u16, shortcuts_h: u16) -> FullPage {
     let nav_h = 3u16;
     let margin_h = 1u16;
     let component_h = area
         .height
         .saturating_sub(nav_h.saturating_add(context_h).saturating_add(shortcuts_h));
     let layout = Layout::default()
         .direction(Direction::Vertical)
         .horizontal_margin(margin_h)
         .constraints(
             [
                 Constraint::Length(nav_h),
                 Constraint::Length(component_h),
                 Constraint::Length(context_h),
                 Constraint::Length(shortcuts_h),
             ]
             .as_ref(),
         )
         .split(area);
     FullPage {
         navigation: layout[0],
         component: layout[1],
         context: layout[2],
         shortcuts: layout[3],
     }
 }
 pub fn default_page(area: Rect, context_h: u16, shortcuts_h: u16) -> DefaultPage {
     let margin_h = 1u16;
     let component_h = area
         .height
         .saturating_sub(context_h.saturating_add(shortcuts_h));
     let layout = Layout::default()
         .direction(Direction::Vertical)
         .horizontal_margin(margin_h)
         .constraints(
             [
                 Constraint::Length(component_h),
                 Constraint::Length(context_h),
                 Constraint::Length(shortcuts_h),
             ]
             .as_ref(),
         )
         .split(area);
     DefaultPage {
         component: layout[0],
         context: layout[1],
         shortcuts: layout[2],
     }
 }
 pub fn headerless_page(area: Rect) -> Vec<Rect> {
     let margin_h = 1u16;
     let content_h = area.height.saturating_sub(margin_h);
     Layout::default()
         .direction(Direction::Vertical)
         .horizontal_margin(margin_h)
         .constraints([Constraint::Length(content_h)].as_ref())
         .split(area)
         .to_vec()
 }
 pub fn root_component_with_context(area: Rect, context_h: u16, shortcuts_h: u16) -> Vec<Rect> {
     let content_h = area
         .height
         .saturating_sub(shortcuts_h.saturating_add(context_h));
     Layout::default()
         .direction(Direction::Vertical)
         .constraints(
             [
                 Constraint::Length(content_h),
                 Constraint::Length(context_h),
                 Constraint::Length(shortcuts_h),
             ]
             .as_ref(),
         )
         .split(area)
         .to_vec()
 }
 pub fn centered_label(label_w: u16, area: Rect) -> Rect {
     let label_h = 1u16;
     let spacer_w = area.width.saturating_sub(label_w).saturating_div(2);
     let spacer_h = area.height.saturating_sub(label_h).saturating_div(2);
     let layout = Layout::default()
         .direction(Direction::Vertical)
         .constraints(
             [
                 Constraint::Length(spacer_h),
                 Constraint::Length(label_h),
                 Constraint::Length(spacer_h),
             ]
             .as_ref(),
         )
         .split(area);
     Layout::default()
         .direction(Direction::Horizontal)
         .constraints(
             [
                 Constraint::Length(spacer_w),
                 Constraint::Length(label_w),
                 Constraint::Length(spacer_w),
             ]
             .as_ref(),
         )
         .split(layout[1])[1]
 }
 pub fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
     let popup_layout = Layout::default()
         .direction(Direction::Vertical)
         .constraints(
             [
                 Constraint::Percentage((100 - percent_y) / 2),
                 Constraint::Percentage(percent_y),
                 Constraint::Percentage((100 - percent_y) / 2),
             ]
             .as_ref(),
         )
         .split(r);
     Layout::default()
         .direction(Direction::Horizontal)
         .constraints(
             [
                 Constraint::Percentage((100 - percent_x) / 2),
                 Constraint::Percentage(percent_x),
                 Constraint::Percentage((100 - percent_x) / 2),
             ]
             .as_ref(),
         )
         .split(popup_layout[1])[1]
 }
 pub fn issue_page(area: Rect, shortcuts_h: u16) -> IssuePage {
     let header_h = 3u16;
     let context_h = 1u16;
     let margin_h = 1u16;
     let content_h = area
         .height
         .saturating_sub(header_h.saturating_add(context_h.saturating_add(shortcuts_h)));
     let root = Layout::default()
         .direction(Direction::Vertical)
         .horizontal_margin(margin_h)
         .constraints(
             [
                 Constraint::Length(header_h),
                 Constraint::Length(content_h),
                 Constraint::Length(context_h),
                 Constraint::Length(shortcuts_h),
             ]
             .as_ref(),
         )
         .split(area);
     let split = Layout::default()
         .direction(Direction::Horizontal)
         .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
         .split(root[1]);
     IssuePage {
         header: root[0],
         left: split[0],
         right: split[1],
         context: root[2],
         shortcuts: root[3],
     }
 }

added src/realm/ui/state.rs

@@ -0,0 +1,163 @@

 use anyhow::anyhow;
 use tuirealm::tui::widgets::{ListState, TableState};
 use tuirealm::{State, StateValue};
 /// State that holds the index of a selected tab item and the count of all tab items.
 /// The index can be increased and will start at 0, if length was reached.
 #[derive(Clone, Default)]
 pub struct TabState {
     pub selected: u16,
     pub len: u16,
 }
 impl TabState {
     pub fn incr_tab_index(&mut self, rewind: bool) {
         if self.selected + 1 < self.len {
             self.selected += 1;
         } else if rewind {
             self.selected = 0;
         }
     }
 }
 #[derive(Clone)]
 pub struct ItemState {
     selected: Option<usize>,
     len: usize,
 }
 impl ItemState {
     pub fn new(selected: Option<usize>, len: usize) -> Self {
         Self { selected, len }
     }
     pub fn selected(&self) -> Option<usize> {
         if !self.is_empty() {
             self.selected
         } else {
             None
         }
     }
     pub fn select_previous(&mut self) -> Option<usize> {
         let old_index = self.selected();
         let new_index = match old_index {
             Some(0) | None => Some(0),
             Some(selected) => Some(selected.saturating_sub(1)),
         };
         if old_index != new_index {
             self.selected = new_index;
             self.selected()
         } else {
             None
         }
     }
     pub fn select_next(&mut self) -> Option<usize> {
         let old_index = self.selected();
         let new_index = match old_index {
             Some(selected) if selected >= self.len.saturating_sub(1) => {
                 Some(self.len.saturating_sub(1))
             }
             Some(selected) => Some(selected.saturating_add(1)),
             None => Some(0),
         };
         if old_index != new_index {
             self.selected = new_index;
             self.selected()
         } else {
             None
         }
     }
     pub fn len(&self) -> usize {
         self.len
     }
     pub fn is_empty(&self) -> bool {
         self.len == 0
     }
 }
 impl TryFrom<State> for ItemState {
     type Error = anyhow::Error;
     fn try_from(state: State) -> Result<Self, Self::Error> {
         match state {
             State::Tup2((StateValue::Usize(selected), StateValue::Usize(len))) => Ok(Self {
                 selected: Some(selected),
                 len,
             }),
             _ => Err(anyhow!(format!(
                 "Cannot convert into item state: {:?}",
                 state
             ))),
         }
     }
 }
 impl From<&ItemState> for TableState {
     fn from(value: &ItemState) -> Self {
         let mut state = TableState::default();
         state.select(value.selected);
         state
     }
 }
 impl From<&ItemState> for ListState {
     fn from(value: &ItemState) -> Self {
         let mut state = ListState::default();
         state.select(value.selected);
         state
     }
 }
 #[derive(Clone)]
 pub struct FormState {
     focus: Option<usize>,
     len: usize,
 }
 impl FormState {
     pub fn new(focus: Option<usize>, len: usize) -> Self {
         Self { focus, len }
     }
     pub fn focus(&self) -> Option<usize> {
         self.focus
     }
     pub fn focus_previous(&mut self) -> Option<usize> {
         let old_index = self.focus();
         let new_index = match old_index {
             Some(0) | None => Some(0),
             Some(focus) => Some(focus.saturating_sub(1)),
         };
         if old_index != new_index {
             self.focus = new_index;
             self.focus()
         } else {
             None
         }
     }
     pub fn focus_next(&mut self) -> Option<usize> {
         let old_index = self.focus();
         let new_index = match old_index {
             Some(focus) if focus >= self.len.saturating_sub(1) => Some(self.len.saturating_sub(1)),
             Some(focus) => Some(focus.saturating_add(1)),
             None => Some(0),
         };
         if old_index != new_index {
             self.focus = new_index;
             self.focus()
         } else {
             None
         }
     }
 }

added src/realm/ui/subscription.rs

@@ -0,0 +1,22 @@

 use tuirealm::event::{Key, KeyEvent, KeyModifiers};
 use tuirealm::SubEventClause;
 pub fn navigation_clause<UserEvent>() -> SubEventClause<UserEvent>
 where
     UserEvent: Clone + Eq + PartialEq + PartialOrd,
 {
     SubEventClause::Keyboard(KeyEvent {
         code: Key::Tab,
         modifiers: KeyModifiers::NONE,
     })
 }
 pub fn quit_clause<UserEvent>(key: Key) -> SubEventClause<UserEvent>
 where
     UserEvent: Clone + Eq + PartialEq + PartialOrd,
 {
     SubEventClause::Keyboard(KeyEvent {
         code: key,
         modifiers: KeyModifiers::NONE,
     })
 }

added src/realm/ui/theme.rs

@@ -0,0 +1,147 @@

 use tuirealm::props::BorderType;
 #[derive(Debug, Clone)]
 pub struct Icons {
     pub property_divider: char,
     pub shortcutbar_divider: char,
     pub tab_divider: char,
     pub tab_overline: char,
     pub whitespace: char,
 }
 #[derive(Debug, Clone)]
 pub struct Tables {
     pub spacing: u16,
 }
 /// The Radicle TUI theme. In the future, it might be defined in a JSON
 /// config file.
 #[derive(Debug, Clone)]
 pub struct Theme {
     pub name: String,
     pub icons: Icons,
     pub tables: Tables,
     pub border_type: BorderType,
 }
 impl Default for Theme {
     fn default() -> Theme {
         Theme {
             name: String::from("Default"),
             icons: Icons {
                 property_divider: '∙',
                 shortcutbar_divider: '∙',
                 tab_divider: '|',
                 tab_overline: '▔',
                 whitespace: ' ',
             },
             tables: Tables { spacing: 2 },
             border_type: BorderType::Rounded,
         }
     }
 }
 pub mod style {
     use tuirealm::props::{Color, Style, TextModifiers};
     pub fn reset() -> Style {
         Style::default().fg(Color::Reset)
     }
     pub fn reset_dim() -> Style {
         Style::default()
             .fg(Color::Reset)
             .add_modifier(TextModifiers::DIM)
     }
     pub fn red() -> Style {
         Style::default().fg(Color::Red)
     }
     pub fn green() -> Style {
         Style::default().fg(Color::Green)
     }
     pub fn yellow() -> Style {
         Style::default().fg(Color::Yellow)
     }
     pub fn yellow_dim() -> Style {
         yellow().add_modifier(TextModifiers::DIM)
     }
     pub fn yellow_dim_reversed() -> Style {
         yellow_dim().add_modifier(TextModifiers::REVERSED)
     }
     pub fn blue() -> Style {
         Style::default().fg(Color::Blue)
     }
     pub fn magenta() -> Style {
         Style::default().fg(Color::Magenta)
     }
     pub fn magenta_dim() -> Style {
         Style::default()
             .fg(Color::Magenta)
             .add_modifier(TextModifiers::DIM)
     }
     pub fn cyan() -> Style {
         Style::default().fg(Color::Cyan)
     }
     pub fn lightblue() -> Style {
         Style::default().fg(Color::LightBlue)
     }
     pub fn gray() -> Style {
         Style::default().fg(Color::Gray)
     }
     pub fn gray_dim() -> Style {
         Style::default()
             .fg(Color::Gray)
             .add_modifier(TextModifiers::DIM)
     }
     pub fn darkgray() -> Style {
         Style::default().fg(Color::DarkGray)
     }
     pub fn reversed() -> Style {
         Style::default().add_modifier(TextModifiers::REVERSED)
     }
     pub fn default_reversed() -> Style {
         Style::default()
             .fg(Color::DarkGray)
             // .add_modifier(TextModifiers::DIM)
             .add_modifier(TextModifiers::REVERSED)
     }
     pub fn magenta_reversed() -> Style {
         Style::default()
             .fg(Color::Magenta)
             .add_modifier(TextModifiers::REVERSED)
     }
     pub fn yellow_reversed() -> Style {
         Style::default().fg(Color::DarkGray).bg(Color::Yellow)
     }
     pub fn border(focus: bool) -> Style {
         if focus {
             gray_dim()
         } else {
             darkgray()
         }
     }
     pub fn highlight() -> Style {
         Style::default()
             .fg(Color::Cyan)
             .add_modifier(TextModifiers::REVERSED)
     }
 }

added src/realm/ui/widget.rs

@@ -0,0 +1,102 @@

 pub mod container;
 pub mod context;
 pub mod form;
 pub mod label;
 pub mod list;
 mod utils;
 use std::ops::Deref;
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::props::{AttrValue, Attribute, Layout, Props, Style};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{Frame, MockComponent, State};
 pub type BoxedWidget<T> = Box<Widget<T>>;
 pub trait WidgetComponent {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect);
     fn state(&self) -> State;
     fn perform(&mut self, properties: &Props, cmd: Cmd) -> CmdResult;
 }
 #[derive(Clone)]
 pub struct Widget<T: WidgetComponent> {
     component: T,
     properties: Props,
 }
 impl<T: WidgetComponent> Deref for Widget<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.component
     }
 }
 impl<T: WidgetComponent> Widget<T> {
     pub fn new(component: T) -> Self {
         Widget {
             component,
             properties: Props::default(),
         }
     }
     pub fn height(mut self, h: u16) -> Self {
         self.attr(Attribute::Height, AttrValue::Size(h));
         self
     }
     pub fn width(mut self, w: u16) -> Self {
         self.attr(Attribute::Width, AttrValue::Size(w));
         self
     }
     pub fn content(mut self, content: AttrValue) -> Self {
         self.attr(Attribute::Content, content);
         self
     }
     pub fn custom(mut self, key: &'static str, value: AttrValue) -> Self {
         self.attr(Attribute::Custom(key), value);
         self
     }
     pub fn layout(mut self, layout: Layout) -> Self {
         self.attr(Attribute::Layout, AttrValue::Layout(layout));
         self
     }
     pub fn style(mut self, style: Style) -> Self {
         self.attr(Attribute::Style, AttrValue::Style(style));
         self
     }
     pub fn to_boxed(self) -> Box<Self> {
         Box::new(self)
     }
 }
 impl<T: WidgetComponent> MockComponent for Widget<T> {
     fn view(&mut self, frame: &mut Frame, area: Rect) {
         self.component.view(&self.properties, frame, area)
     }
     fn query(&self, attr: Attribute) -> Option<AttrValue> {
         self.properties.get(attr)
     }
     fn attr(&mut self, attr: Attribute, value: AttrValue) {
         self.properties.set(attr, value)
     }
     fn state(&self) -> State {
         self.component.state()
     }
     fn perform(&mut self, cmd: Cmd) -> CmdResult {
         self.component.perform(&self.properties, cmd)
     }
 }

added src/realm/ui/widget/common.rs

@@ -0,0 +1,186 @@

 pub mod container;
 pub mod context;
 pub mod form;
 pub mod label;
 pub mod list;
 use tuirealm::props::{AttrValue, Attribute};
 use tuirealm::MockComponent;
 use container::{GlobalListener, Header, LabeledContainer, Tabs};
 use context::{Shortcut, Shortcuts};
 use label::Label;
 use list::{Property, PropertyList};
 use self::container::{AppHeader, AppInfo, Container, Popup, VerticalLine};
 use self::label::Textarea;
 use self::list::{ColumnWidth, PropertyTable};
 use super::Widget;
 use crate::ui::context::Context;
 use crate::ui::theme::Theme;
 pub fn global_listener() -> Widget<GlobalListener> {
     Widget::new(GlobalListener::default())
 }
 pub fn label(content: &str) -> Widget<Label> {
     // TODO: Remove when size constraints are implemented
     let width = content.chars().count() as u16;
     Widget::new(Label)
         .content(AttrValue::String(content.to_string()))
         .height(1)
         .width(width)
 }
 pub fn reversable_label(content: &str) -> Widget<Label> {
     let content = &format!(" {content} ");
     label(content)
 }
 pub fn container_header(theme: &Theme, label: Widget<Label>) -> Widget<Header<1>> {
     let header = Header::new([label], [ColumnWidth::Grow], theme.clone());
     Widget::new(header)
 }
 pub fn container(theme: &Theme, component: Box<dyn MockComponent>) -> Widget<Container> {
     let container = Container::new(component, theme.clone());
     Widget::new(container)
 }
 pub fn labeled_container(
     theme: &Theme,
     title: &str,
     component: Box<dyn MockComponent>,
 ) -> Widget<LabeledContainer> {
     let header = container_header(
         theme,
         label(&format!(" {title} ")).foreground(theme.colors.default_fg),
     );
     let container = LabeledContainer::new(header, component, theme.clone());
     Widget::new(container)
 }
 pub fn shortcut(theme: &Theme, short: &str, long: &str) -> Widget<Shortcut> {
     let short = label(short).foreground(theme.colors.shortcut_short_fg);
     let divider = label(&theme.icons.whitespace.to_string());
     let long = label(long).foreground(theme.colors.shortcut_long_fg);
     // TODO: Remove when size constraints are implemented
     let short_w = short.query(Attribute::Width).unwrap().unwrap_size();
     let divider_w = divider.query(Attribute::Width).unwrap().unwrap_size();
     let long_w = long.query(Attribute::Width).unwrap().unwrap_size();
     let width = short_w.saturating_add(divider_w).saturating_add(long_w);
     let shortcut = Shortcut::new(short, divider, long);
     Widget::new(shortcut).height(1).width(width)
 }
 pub fn shortcuts(theme: &Theme, shortcuts: Vec<Widget<Shortcut>>) -> Widget<Shortcuts> {
     let divider = label(&format!(" {} ", theme.icons.shortcutbar_divider))
         .foreground(theme.colors.shortcutbar_divider_fg);
     let shortcut_bar = Shortcuts::new(shortcuts, divider);
     Widget::new(shortcut_bar).height(1)
 }
 pub fn property(theme: &Theme, name: &str, value: &str) -> Widget<Property> {
     let name = label(name).foreground(theme.colors.property_name_fg);
     let divider = label(&format!(" {} ", theme.icons.property_divider));
     let value = label(value).foreground(theme.colors.default_fg);
     // TODO: Remove when size constraints are implemented
     let name_w = name.query(Attribute::Width).unwrap().unwrap_size();
     let divider_w = divider.query(Attribute::Width).unwrap().unwrap_size();
     let value_w = value.query(Attribute::Width).unwrap().unwrap_size();
     let width = name_w.saturating_add(divider_w).saturating_add(value_w);
     let property = Property::new(name, value).with_divider(divider);
     Widget::new(property).height(1).width(width)
 }
 pub fn property_list(_theme: &Theme, properties: Vec<Widget<Property>>) -> Widget<PropertyList> {
     let property_list = PropertyList::new(properties);
     Widget::new(property_list)
 }
 pub fn property_table(_theme: &Theme, properties: Vec<Widget<Property>>) -> Widget<PropertyTable> {
     let table = PropertyTable::new(properties);
     Widget::new(table)
 }
 pub fn tabs(_theme: &Theme, tabs: Vec<Widget<Label>>) -> Widget<Tabs> {
     let tabs = Tabs::new(tabs);
     Widget::new(tabs).height(2)
 }
 pub fn app_info(context: &Context, theme: &Theme) -> Widget<AppInfo> {
     let project = label(context.project().name()).foreground(theme.colors.app_header_project_fg);
     let rid = label(&format!(" ({})", context.id())).foreground(theme.colors.app_header_rid_fg);
     let project_w = project
         .query(Attribute::Width)
         .unwrap_or(AttrValue::Size(0))
         .unwrap_size();
     let rid_w = rid
         .query(Attribute::Width)
         .unwrap_or(AttrValue::Size(0))
         .unwrap_size();
     let info = AppInfo::new(project, rid);
     Widget::new(info).width(project_w.saturating_add(rid_w))
 }
 pub fn app_header(
     context: &Context,
     theme: &Theme,
     nav: Option<Widget<Tabs>>,
 ) -> Widget<AppHeader> {
     let line =
         label(&theme.icons.tab_overline.to_string()).foreground(theme.colors.tabs_highlighted_fg);
     let line = Widget::new(VerticalLine::new(line));
     let info = app_info(context, theme);
     let header = AppHeader::new(nav, info, line);
     Widget::new(header)
 }
 pub fn info(theme: &Theme, message: &str) -> Widget<Popup> {
     let textarea =
         Widget::new(Textarea::new(theme.clone())).content(AttrValue::String(message.to_owned()));
     let container = labeled_container(theme, "Info", textarea.to_boxed());
     Widget::new(Popup::new(theme.clone(), container))
         .width(50)
         .height(20)
 }
 pub fn warning(theme: &Theme, message: &str) -> Widget<Popup> {
     let textarea =
         Widget::new(Textarea::new(theme.clone())).content(AttrValue::String(message.to_owned()));
     let container = labeled_container(theme, "Warning", textarea.to_boxed());
     Widget::new(Popup::new(theme.clone(), container))
         .width(50)
         .height(20)
 }
 pub fn error(theme: &Theme, message: &str) -> Widget<Popup> {
     let textarea =
         Widget::new(Textarea::new(theme.clone())).content(AttrValue::String(message.to_owned()));
     let container = labeled_container(theme, "Error", textarea.to_boxed());
     Widget::new(Popup::new(theme.clone(), container))
         .width(50)
         .height(20)
 }

added src/realm/ui/widget/container.rs

@@ -0,0 +1,484 @@

 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::props::{AttrValue, Attribute, BorderSides, Props, TextModifiers};
 use tuirealm::tui::layout::{Constraint, Direction, Layout, Margin, Rect};
 use tuirealm::tui::widgets::{Block, Cell, Clear, Row};
 use tuirealm::{Frame, MockComponent, State, StateValue};
 use crate::realm::ui::ext::HeaderBlock;
 use crate::realm::ui::layout;
 use crate::realm::ui::state::TabState;
 use crate::realm::ui::theme::{style, Theme};
 use crate::realm::ui::widget::{utils, Widget, WidgetComponent};
 use super::label::Label;
 use super::list::ColumnWidth;
 /// Some user events need to be handled globally (e.g. user presses key `q` to quit
 /// the application). This component can be used in conjunction with SubEventClause
 /// to handle those events.
 #[derive(Default)]
 pub struct GlobalListener {}
 impl WidgetComponent for GlobalListener {
     fn view(&mut self, _properties: &Props, _frame: &mut Frame, _area: Rect) {}
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 /// A vertical separator.
 #[derive(Clone)]
 pub struct VerticalLine {
     line: Widget<Label>,
 }
 impl VerticalLine {
     pub fn new(line: Widget<Label>) -> Self {
         Self { line }
     }
 }
 impl WidgetComponent for VerticalLine {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             // Repeat and render line.
             let overlines = vec![self.line.clone(); area.width as usize];
             let overlines = overlines
                 .iter()
                 .map(|l| l.clone().to_boxed() as Box<dyn MockComponent>)
                 .collect();
             let line_layout = layout::h_stack(overlines, area);
             for (mut line, area) in line_layout {
                 line.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 /// A tab header that displays all labels horizontally aligned and separated
 /// by a divider. Highlights the label defined by the current tab index.
 #[derive(Clone)]
 pub struct Tabs {
     tabs: Vec<Widget<Label>>,
     state: TabState,
 }
 impl Tabs {
     pub fn new(tabs: Vec<Widget<Label>>) -> Self {
         let count = &tabs.len();
         Self {
             tabs,
             state: TabState {
                 selected: 0,
                 len: *count as u16,
             },
         }
     }
 }
 impl WidgetComponent for Tabs {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let selected = self.state().unwrap_one().unwrap_u16();
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             // Render tabs, highlighting the selected tab.
             let mut tabs = vec![];
             for (index, tab) in self.tabs.iter().enumerate() {
                 let mut tab = tab.clone().to_boxed();
                 if index == selected as usize {
                     tab.attr(
                         Attribute::TextProps,
                         AttrValue::TextModifiers(TextModifiers::REVERSED),
                     );
                 }
                 tabs.push(tab.clone().to_boxed() as Box<dyn MockComponent>);
             }
             tabs.push(Widget::new(Label).to_boxed());
             let tab_layout = layout::h_stack(tabs, area);
             for (mut tab, area) in tab_layout {
                 tab.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::One(StateValue::U16(self.state.selected))
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         use tuirealm::command::Direction;
         match cmd {
             Cmd::Move(Direction::Right) => {
                 let prev = self.state.selected;
                 self.state.incr_tab_index(true);
                 if prev != self.state.selected {
                     CmdResult::Changed(self.state())
                 } else {
                     CmdResult::None
                 }
             }
             _ => CmdResult::None,
         }
     }
 }
 /// An application info widget that renders project / branch information
 /// and a separator line. Used in conjunction with [`Tabs`].
 pub struct AppInfo {
     project: Widget<Label>,
     rid: Widget<Label>,
 }
 impl AppInfo {
     pub fn new(project: Widget<Label>, rid: Widget<Label>) -> Self {
         Self { project, rid }
     }
 }
 impl WidgetComponent for AppInfo {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let project_w = self
             .project
             .query(Attribute::Width)
             .unwrap_or(AttrValue::Size(10))
             .unwrap_size();
         let rid_w = self
             .rid
             .query(Attribute::Width)
             .unwrap_or(AttrValue::Size(10))
             .unwrap_size();
         if display {
             let layout = Layout::default()
                 .direction(Direction::Horizontal)
                 .constraints(vec![
                     Constraint::Length(project_w),
                     Constraint::Length(rid_w),
                 ])
                 .split(area);
             self.project.view(frame, layout[0]);
             self.rid.view(frame, layout[1]);
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 /// A common application header that renders project / branch
 /// information and an optional navigation.
 pub struct AppHeader {
     nav: Option<Widget<Tabs>>,
     info: Widget<AppInfo>,
     line: Widget<VerticalLine>,
 }
 impl AppHeader {
     pub fn new(
         nav: Option<Widget<Tabs>>,
         info: Widget<AppInfo>,
         line: Widget<VerticalLine>,
     ) -> Self {
         Self { nav, info, line }
     }
 }
 impl WidgetComponent for AppHeader {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let info_w = self
             .info
             .query(Attribute::Width)
             .unwrap_or(AttrValue::Size(10))
             .unwrap_size();
         if display {
             let layout = layout::app_header(area, info_w);
             if let Some(nav) = self.nav.as_mut() {
                 nav.view(frame, layout.nav);
             }
             self.info.view(frame, layout.info);
             self.line.view(frame, layout.line);
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.nav
             .as_mut()
             .map(|nav| nav.perform(cmd))
             .unwrap_or(CmdResult::None)
     }
 }
 /// A labeled container header.
 pub struct Header<const W: usize> {
     header: [Widget<Label>; W],
     widths: [ColumnWidth; W],
     theme: Theme,
 }
 impl<const W: usize> Header<W> {
     pub fn new(header: [Widget<Label>; W], widths: [ColumnWidth; W], theme: Theme) -> Self {
         Self {
             header,
             widths,
             theme,
         }
     }
 }
 impl<const W: usize> WidgetComponent for Header<W> {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         if display {
             let block = HeaderBlock::default()
                 .borders(BorderSides::all())
                 .border_style(style::border(focus))
                 .border_type(self.theme.border_type);
             frame.render_widget(block, area);
             let layout = Layout::default()
                 .direction(Direction::Vertical)
                 .constraints(vec![Constraint::Min(1)])
                 .vertical_margin(1)
                 .horizontal_margin(1)
                 .split(area);
             let widths = utils::column_widths(area, &self.widths, self.theme.tables.spacing);
             let header: [Cell; W] = self
                 .header
                 .iter()
                 .map(|label| {
                     let cell: Cell = label.into();
                     cell.style(style::reset())
                 })
                 .collect::<Vec<_>>()
                 .try_into()
                 .unwrap();
             let header: Row<'_> = Row::new(header);
             let table = tuirealm::tui::widgets::Table::new(vec![])
                 .column_spacing(self.theme.tables.spacing)
                 .header(header)
                 .widths(&widths);
             frame.render_widget(table, layout[0]);
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 pub struct Container {
     component: Box<dyn MockComponent>,
     theme: Theme,
 }
 impl Container {
     pub fn new(component: Box<dyn MockComponent>, theme: Theme) -> Self {
         Self { component, theme }
     }
 }
 impl WidgetComponent for Container {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         if display {
             // Make some space on the left
             let layout = Layout::default()
                 .direction(Direction::Horizontal)
                 .horizontal_margin(1)
                 .vertical_margin(1)
                 .constraints(vec![Constraint::Length(1), Constraint::Min(0)])
                 .split(area);
             // reverse draw order: child needs to be drawn first?
             self.component
                 .attr(Attribute::Focus, AttrValue::Flag(focus));
             self.component.view(frame, layout[1]);
             let block = Block::default()
                 .borders(BorderSides::ALL)
                 .border_style(style::border(focus))
                 .border_type(self.theme.border_type);
             frame.render_widget(block, area);
         }
     }
     fn state(&self) -> State {
         self.component.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.component.perform(cmd)
     }
 }
 pub struct LabeledContainer {
     header: Widget<Header<1>>,
     component: Box<dyn MockComponent>,
     theme: Theme,
 }
 impl LabeledContainer {
     pub fn new(header: Widget<Header<1>>, component: Box<dyn MockComponent>, theme: Theme) -> Self {
         Self {
             header,
             component,
             theme,
         }
     }
 }
 impl WidgetComponent for LabeledContainer {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         let header_height = self
             .header
             .query(Attribute::Height)
             .unwrap_or(AttrValue::Size(3))
             .unwrap_size();
         if display {
             let layout = Layout::default()
                 .direction(Direction::Vertical)
                 .constraints([Constraint::Length(header_height), Constraint::Min(1)].as_ref())
                 .split(area);
             self.header.attr(Attribute::Focus, AttrValue::Flag(focus));
             self.header.view(frame, layout[0]);
             let block = Block::default()
                 .borders(BorderSides::BOTTOM | BorderSides::LEFT | BorderSides::RIGHT)
                 .border_style(style::border(focus))
                 .border_type(self.theme.border_type);
             frame.render_widget(block.clone(), layout[1]);
             self.component
                 .attr(Attribute::Focus, AttrValue::Flag(focus));
             self.component.view(
                 frame,
                 block.inner(layout[1]).inner(&Margin {
                     vertical: 0,
                     horizontal: 1,
                 }),
             );
         }
     }
     fn state(&self) -> State {
         self.component.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.component.perform(cmd)
     }
 }
 pub struct Popup {
     component: Widget<LabeledContainer>,
 }
 impl Popup {
     pub fn new(_theme: Theme, component: Widget<LabeledContainer>) -> Self {
         Self { component }
     }
 }
 impl WidgetComponent for Popup {
     fn view(&mut self, properties: &Props, frame: &mut Frame, _area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         let width = properties
             .get_or(Attribute::Width, AttrValue::Size(50))
             .unwrap_size();
         let height = properties
             .get_or(Attribute::Height, AttrValue::Size(50))
             .unwrap_size();
         if display {
             let size = frame.size();
             let area = layout::centered_rect(width, height, size);
             frame.render_widget(Clear, area);
             self.component
                 .attr(Attribute::Focus, AttrValue::Flag(focus));
             self.component.view(frame, area);
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.component.perform(cmd)
     }
 }

added src/realm/ui/widget/context.rs

@@ -0,0 +1,233 @@

 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::props::{AttrValue, Attribute, Props};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{Frame, MockComponent, State};
 use super::label::{self, Label, LabelGroup};
 use crate::realm::ui::layout;
 use crate::realm::ui::theme::{style, Theme};
 use crate::realm::ui::widget::{Widget, WidgetComponent};
 pub enum Progress {
     Percentage(usize),
     Step(usize, usize),
     None,
 }
 impl ToString for Progress {
     fn to_string(&self) -> std::string::String {
         match self {
             Progress::Percentage(value) => format!("{value} %"),
             Progress::Step(step, total) => format!("{step}/{total}"),
             _ => String::new(),
         }
     }
 }
 /// A shortcut that consists of a label displaying the "hotkey", a label that displays
 /// the action and a spacer between them.
 #[derive(Clone)]
 pub struct Shortcut {
     short: Widget<Label>,
     divider: Widget<Label>,
     long: Widget<Label>,
 }
 impl Shortcut {
     pub fn new(short: Widget<Label>, divider: Widget<Label>, long: Widget<Label>) -> Self {
         Self {
             short,
             divider,
             long,
         }
     }
 }
 impl WidgetComponent for Shortcut {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             let labels: Vec<Box<dyn MockComponent>> = vec![
                 self.short.clone().to_boxed(),
                 self.divider.clone().to_boxed(),
                 self.long.clone().to_boxed(),
             ];
             let layout = layout::h_stack(labels, area);
             for (mut shortcut, area) in layout {
                 shortcut.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 /// A shortcut bar that displays multiple shortcuts and separates them with a
 /// divider.
 #[derive(Clone)]
 pub struct Shortcuts {
     shortcuts: Vec<Widget<Shortcut>>,
     divider: Widget<Label>,
 }
 impl Shortcuts {
     pub fn new(shortcuts: Vec<Widget<Shortcut>>, divider: Widget<Label>) -> Self {
         Self { shortcuts, divider }
     }
 }
 impl WidgetComponent for Shortcuts {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             let mut widgets: Vec<Box<dyn MockComponent>> = vec![];
             let mut shortcuts = self.shortcuts.iter_mut().peekable();
             while let Some(shortcut) = shortcuts.next() {
                 if shortcuts.peek().is_some() {
                     widgets.push(shortcut.clone().to_boxed());
                     widgets.push(self.divider.clone().to_boxed())
                 } else {
                     widgets.push(shortcut.clone().to_boxed());
                 }
             }
             let layout = layout::h_stack(widgets, area);
             for (mut widget, area) in layout {
                 widget.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 pub struct ContextBar {
     col_0: Widget<LabelGroup>,
     col_1: Widget<LabelGroup>,
     col_2: Widget<LabelGroup>,
     col_3: Widget<LabelGroup>,
     col_4: Widget<LabelGroup>,
 }
 impl ContextBar {
     pub const PROP_EDIT_MODE: &'static str = "edit-mode";
     pub fn new(
         col_0: Widget<LabelGroup>,
         col_1: Widget<LabelGroup>,
         col_2: Widget<LabelGroup>,
         col_3: Widget<LabelGroup>,
         col_4: Widget<LabelGroup>,
     ) -> Self {
         Self {
             col_0,
             col_1,
             col_2,
             col_3,
             col_4,
         }
     }
 }
 impl WidgetComponent for ContextBar {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let edit_mode = properties
             .get_or(
                 Attribute::Custom(Self::PROP_EDIT_MODE),
                 AttrValue::Flag(false),
             )
             .unwrap_flag();
         let col_0_w = self.col_0.query(Attribute::Width).unwrap().unwrap_size();
         let col_1_w = self.col_1.query(Attribute::Width).unwrap().unwrap_size();
         let col_3_w = self.col_3.query(Attribute::Width).unwrap().unwrap_size();
         let col_4_w = self.col_4.query(Attribute::Width).unwrap().unwrap_size();
         if edit_mode {
             self.col_0.attr(
                 Attribute::Background,
                 AttrValue::Color(style::yellow_reversed().bg.unwrap()),
             )
         }
         if display {
             let content_layout = layout::h_stack(
                 vec![
                     self.col_0.clone().to_boxed(),
                     self.col_1.clone().to_boxed(),
                     self.col_2
                         .clone()
                         .width(
                             area.width
                                 .saturating_sub(col_0_w + col_1_w + col_3_w + col_4_w),
                         )
                         .to_boxed(),
                     self.col_3.clone().to_boxed(),
                     self.col_4.clone().to_boxed(),
                 ],
                 area,
             );
             for (mut component, area) in content_layout {
                 component.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 pub fn bar(
     _theme: &Theme,
     label_0: &str,
     label_1: &str,
     label_2: &str,
     label_3: &str,
     label_4: &str,
 ) -> Widget<ContextBar> {
     let label_0 = label::badge(&format!(" {label_0} "));
     let label_1 = label::default_reversed(&format!(" {label_1} "));
     let label_2 = label::default_reversed(&format!(" {label_2} "));
     let label_3 = label::default_reversed(&format!(" {label_3} "));
     let label_4 = label::default_reversed(&format!(" {label_4} "));
     let label_0 = label::group(&[label_0]);
     let label_1 = label::group(&[label_1]);
     let label_2 = label::group(&[label_2]);
     let label_3 = label::group(&[label_3]);
     let label_4 = label::group(&[label_4]);
     let context_bar = ContextBar::new(label_0, label_1, label_2, label_3, label_4);
     Widget::new(context_bar).height(1)
 }

added src/realm/ui/widget/form.rs

@@ -0,0 +1,268 @@

 use std::collections::LinkedList;
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::{Constraint, Direction, Margin, Rect};
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State, StateValue};
 use crate::realm::ui::state::FormState;
 use crate::realm::ui::theme::{style, Theme};
 use crate::realm::ui::widget::{Widget, WidgetComponent};
 use super::container::Container;
 use super::label::{self, Label};
 pub struct TextField {
     input: Widget<Container>,
     placeholder: Widget<Label>,
     show_placeholder: bool,
 }
 impl TextField {
     pub fn new(theme: Theme, title: &str) -> Self {
         // TODO: activate again
         // let input = tui_realm_textarea::TextArea::default()
         //     .wrap(false)
         //     .single_line(true)
         //     .cursor_line_style(Style::reset())
         //     .style(style::reset());
         let input = tui_realm_stdlib::Textarea::default();
         let container = crate::realm::ui::container(&theme, Box::new(input));
         Self {
             input: container,
             placeholder: label::default(title).style(style::gray_dim()),
             show_placeholder: true,
         }
     }
 }
 impl WidgetComponent for TextField {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.input.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.input.view(frame, area);
         if self.show_placeholder {
             let inner = area.inner(&Margin {
                 vertical: 1,
                 horizontal: 2,
             });
             self.placeholder.view(frame, inner);
         }
     }
     fn state(&self) -> State {
         if let State::Vec(values) = self.input.state() {
             let text = match values.get(0) {
                 Some(StateValue::String(line)) => line.clone(),
                 _ => String::new(),
             };
             State::One(StateValue::String(text))
         } else {
             State::None
         }
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         // TODO: activate again
         // use tui_realm_textarea::*;
         // let cmd = match cmd {
         //     Cmd::Custom(Form::CMD_PASTE) => Cmd::Custom(TEXTAREA_CMD_PASTE),
         //     _ => cmd,
         // };
         // let result = self.input.perform(cmd);
         // if let State::Vec(values) = self.input.state() {
         //     if let Some(StateValue::String(input)) = values.first() {
         //         self.show_placeholder = values.len() == 1 && input.is_empty();
         //     } else {
         //         self.show_placeholder = false;
         //     }
         // }
         // result
         CmdResult::None
     }
 }
 pub struct TextArea {
     input: Widget<Container>,
     placeholder: Widget<Label>,
     show_placeholder: bool,
 }
 impl TextArea {
     pub fn new(theme: Theme, title: &str) -> Self {
         // TODO: activate again
         // let input = tui_realm_textarea::TextArea::default()
         //     .wrap(true)
         //     .single_line(false)
         //     .cursor_line_style(Style::reset())
         //     .style(style::reset());
         let input = tui_realm_stdlib::Textarea::default();
         let container = crate::realm::ui::container(&theme, Box::new(input));
         Self {
             input: container,
             placeholder: label::default(title).style(style::gray_dim()),
             show_placeholder: true,
         }
     }
 }
 impl WidgetComponent for TextArea {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.input.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.input.view(frame, area);
         if self.show_placeholder {
             let inner = area.inner(&Margin {
                 vertical: 1,
                 horizontal: 2,
             });
             self.placeholder.view(frame, inner);
         }
     }
     fn state(&self) -> State {
         // Fold each input's vector of lines into a single string.
         if let State::Vec(values) = self.input.state() {
             let mut text = String::new();
             let lines = values
                 .iter()
                 .map(|value| match value {
                     StateValue::String(line) => line.clone(),
                     _ => String::new(),
                 })
                 .collect::<Vec<_>>();
             let mut lines = lines.iter().peekable();
             while let Some(line) = lines.next() {
                 text.push_str(line);
                 if lines.peek().is_some() {
                     text.push('\n');
                 }
             }
             State::One(StateValue::String(text))
         } else {
             State::None
         }
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         // TODO: activate again
         // use tui_realm_textarea::*;
         // let cmd = match cmd {
         //     Cmd::Custom(Form::CMD_PASTE) => Cmd::Custom(TEXTAREA_CMD_PASTE),
         //     Cmd::Custom(Form::CMD_NEWLINE) => Cmd::Custom(TEXTAREA_CMD_NEWLINE),
         //     _ => cmd,
         // };
         // let result = self.input.perform(cmd);
         // if let State::Vec(values) = self.input.state() {
         //     if let Some(StateValue::String(input)) = values.first() {
         //         self.show_placeholder = values.len() == 1 && input.is_empty();
         //     } else {
         //         self.show_placeholder = false;
         //     }
         // }
         // result
         CmdResult::None
     }
 }
 pub struct Form {
     // This form's fields: title, tags, assignees, description.
     inputs: Vec<Box<dyn MockComponent>>,
     /// State that holds the current focus etc.
     state: FormState,
 }
 impl Form {
     pub const CMD_FOCUS_PREVIOUS: &'static str = "cmd-focus-previous";
     pub const CMD_FOCUS_NEXT: &'static str = "cmd-focus-next";
     pub const CMD_NEWLINE: &'static str = "cmd-newline";
     pub const CMD_PASTE: &'static str = "cmd-paste";
     pub const PROP_ID: &'static str = "prop-id";
     pub fn new(_theme: Theme, inputs: Vec<Box<dyn MockComponent>>) -> Self {
         let state = FormState::new(Some(0), inputs.len());
         Self { inputs, state }
     }
 }
 impl WidgetComponent for Form {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         use tuirealm::props::Layout;
         // Clear and set current focus
         let focus = self.state.focus().unwrap_or(0);
         for input in &mut self.inputs {
             input.attr(Attribute::Focus, AttrValue::Flag(false));
         }
         if let Some(input) = self.inputs.get_mut(focus) {
             input.attr(Attribute::Focus, AttrValue::Flag(true));
         }
         let layout = Layout::default()
             .direction(Direction::Vertical)
             .constraints(
                 &self
                     .inputs
                     .iter()
                     .map(|_| Constraint::Length(3))
                     .collect::<Vec<_>>(),
             );
         let layout = properties
             .get_or(Attribute::Layout, AttrValue::Layout(layout))
             .unwrap_layout();
         let layout = layout.chunks(area);
         for (index, area) in layout.iter().enumerate().take(self.inputs.len()) {
             if let Some(input) = self.inputs.get_mut(index) {
                 input.view(frame, *area);
             }
         }
     }
     fn state(&self) -> State {
         let states = self
             .inputs
             .iter()
             .map(|input| input.state())
             .collect::<LinkedList<_>>();
         State::Linked(states)
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         match cmd {
             Cmd::Custom(Self::CMD_FOCUS_PREVIOUS) => {
                 self.state.focus_previous();
                 CmdResult::None
             }
             Cmd::Custom(Self::CMD_FOCUS_NEXT) => {
                 self.state.focus_next();
                 CmdResult::None
             }
             Cmd::Submit => CmdResult::Submit(self.state()),
             _ => {
                 let focus = self.state.focus().unwrap_or(0);
                 if let Some(input) = self.inputs.get_mut(focus) {
                     return input.perform(cmd);
                 }
                 CmdResult::None
             }
         }
     }
 }

added src/realm/ui/widget/label.rs

@@ -0,0 +1,352 @@

 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::props::{Alignment, AttrValue, Attribute, Color, Props, Style};
 use tuirealm::tui::layout::{Constraint, Direction, Layout, Rect};
 use tuirealm::tui::text::{Line, Span, Text};
 use tuirealm::{Frame, MockComponent, State, StateValue};
 use crate::realm::ui::layout;
 use crate::realm::ui::theme::style;
 use crate::realm::ui::widget::{Widget, WidgetComponent};
 pub fn blank() -> Widget<Label> {
     default("")
 }
 pub fn default(content: &str) -> Widget<Label> {
     // TODO: Remove when size constraints are implemented
     let width = content.chars().count() as u16;
     Widget::new(Label)
         .content(AttrValue::String(content.to_string()))
         .height(1)
         .width(width)
 }
 pub fn reversed(content: &str) -> Widget<Label> {
     default(content).style(style::reversed())
 }
 pub fn default_reversed(content: &str) -> Widget<Label> {
     default(content).style(style::default_reversed())
 }
 pub fn group(labels: &[Widget<Label>]) -> Widget<LabelGroup> {
     let group = LabelGroup::new(labels);
     let width = labels.iter().fold(0, |total, label| {
         total
             + label
                 .query(Attribute::Width)
                 .unwrap_or(AttrValue::Size(0))
                 .unwrap_size()
     });
     Widget::new(group).width(width)
 }
 pub fn reversable(content: &str) -> Widget<Label> {
     let content = &format!(" {content} ");
     default(content)
 }
 pub fn header(content: &str) -> Widget<Label> {
     default(content).style(style::reset_dim())
 }
 pub fn property(content: &str) -> Widget<Label> {
     default(content).style(style::cyan())
 }
 pub fn property_divider(content: &str) -> Widget<Label> {
     default(content).style(style::gray())
 }
 pub fn badge(content: &str) -> Widget<Label> {
     default(content).style(style::magenta_reversed())
 }
 pub fn title(content: &str) -> Widget<Label> {
     default(content)
 }
 pub fn labels(content: &str) -> Widget<Label> {
     default(content).style(style::lightblue())
 }
 pub fn alias(content: &str) -> Widget<Label> {
     default(content).style(style::magenta())
 }
 pub fn did(content: &str) -> Widget<Label> {
     default(content).style(style::magenta_dim())
 }
 pub fn id(content: &str) -> Widget<Label> {
     default(content).style(style::cyan())
 }
 pub fn oid(content: &str) -> Widget<Label> {
     default(content).style(style::lightblue())
 }
 pub fn timestamp(content: &str) -> Widget<Label> {
     default(content).style(style::gray_dim())
 }
 pub fn positive(content: &str) -> Widget<Label> {
     default(content).style(style::green())
 }
 pub fn negative(content: &str) -> Widget<Label> {
     default(content).style(style::red())
 }
 /// A label that can be styled using a foreground color and text modifiers.
 /// Its height is fixed, its width depends on the length of the text it displays.
 #[derive(Clone, Default)]
 pub struct Label;
 impl WidgetComponent for Label {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         use tui_realm_stdlib::Label;
         let content = properties
             .get_or(Attribute::Content, AttrValue::String(String::default()))
             .unwrap_string();
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let style = properties
             .get_or(Attribute::Style, AttrValue::Style(Style::default()))
             .unwrap_style();
         if display {
             let mut label = Label::default()
                 .foreground(style.fg.unwrap_or(Color::Reset))
                 .background(style.bg.unwrap_or(Color::Reset))
                 .modifiers(style.add_modifier)
                 .text(content);
             label.view(frame, area);
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 impl From<&Widget<Label>> for Span<'_> {
     fn from(label: &Widget<Label>) -> Self {
         let content = label
             .query(Attribute::Content)
             .unwrap_or(AttrValue::String(String::default()))
             .unwrap_string();
         let style = label
             .query(Attribute::Style)
             .unwrap_or(AttrValue::Style(Style::default()))
             .unwrap_style();
         Span::styled(content, style)
     }
 }
 impl From<Widget<Label>> for Span<'_> {
     fn from(label: Widget<Label>) -> Self {
         let content = label
             .query(Attribute::Content)
             .unwrap_or(AttrValue::String(String::default()))
             .unwrap_string();
         let style = label
             .query(Attribute::Style)
             .unwrap_or(AttrValue::Style(Style::default()))
             .unwrap_style();
         Span::styled(content, style)
     }
 }
 impl From<&Widget<Label>> for Text<'_> {
     fn from(label: &Widget<Label>) -> Self {
         let content = label
             .query(Attribute::Content)
             .unwrap_or(AttrValue::String(String::default()))
             .unwrap_string();
         let style = label
             .query(Attribute::Style)
             .unwrap_or(AttrValue::Style(Style::default()))
             .unwrap_style();
         Text::styled(content, style)
     }
 }
 impl From<Widget<Label>> for Text<'_> {
     fn from(label: Widget<Label>) -> Self {
         let content = label
             .query(Attribute::Content)
             .unwrap_or(AttrValue::String(String::default()))
             .unwrap_string();
         let style = label
             .query(Attribute::Style)
             .unwrap_or(AttrValue::Style(Style::default()))
             .unwrap_style();
         Text::styled(content, style)
     }
 }
 #[derive(Clone, Default)]
 pub struct LabelGroup {
     labels: Vec<Widget<Label>>,
 }
 impl LabelGroup {
     pub fn new(labels: &[Widget<Label>]) -> Self {
         Self {
             labels: labels.to_vec(),
         }
     }
 }
 impl WidgetComponent for LabelGroup {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             let mut labels: Vec<Box<dyn MockComponent>> = vec![];
             for label in &self.labels {
                 labels.push(label.clone().to_boxed());
             }
             let layout = layout::h_stack(labels, area);
             for (mut label, area) in layout {
                 label.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 #[derive(Default)]
 pub struct Textarea {
     /// The scroll offset.
     offset: usize,
     /// The current line count.
     len: usize,
     /// The current display height.
     height: usize,
     /// The percentage scrolled.
     scroll_percent: usize,
 }
 impl Textarea {
     pub const PROP_DISPLAY_PROGRESS: &'static str = "display-progress";
     fn scroll_percent(offset: usize, len: usize, height: usize) -> usize {
         if height >= len {
 
         } else {
             let y = offset as f64;
             let h = height as f64;
             let t = len.saturating_sub(1) as f64;
             let v = y / (t - h) * 100_f64;
             std::cmp::max(0, std::cmp::min(100, v as usize))
         }
     }
 }
 impl WidgetComponent for Textarea {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         use tuirealm::tui::widgets::Paragraph;
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         let display_progress = properties
             .get_or(
                 Attribute::Custom(Self::PROP_DISPLAY_PROGRESS),
                 AttrValue::Flag(false),
             )
             .unwrap_flag();
         let content = properties
             .get_or(Attribute::Content, AttrValue::String(String::default()))
             .unwrap_string();
         let layout = Layout::default()
             .direction(Direction::Vertical)
             .constraints([Constraint::Min(1), Constraint::Length(1)])
             .split(area);
         // TODO: replace with `ratatui`'s reflow module when that becomes
         // public: https://github.com/tui-rs-revival/ratatui/pull/9.
         //
         // In the future, there should be highlighting for e.g. Markdown which
         // needs be done before wrapping. So this should rather wrap styled text
         // spans than plain text.
         let body = textwrap::wrap(&content, area.width.saturating_sub(2) as usize);
         self.len = body.len();
         self.height = (layout[0].height - 1) as usize;
         let body: String = body.iter().fold(String::new(), |mut body, line| {
             body.push_str(&format!("{}\n", line));
             body
         });
         let paragraph = Paragraph::new(body)
             .scroll((self.offset as u16, 0))
             .style(style::reset());
         frame.render_widget(paragraph, layout[0]);
         self.scroll_percent = Self::scroll_percent(self.offset, self.len, self.height);
         if display_progress {
             let progress = Line::from(vec![Span::styled(
                 format!("{} %", self.scroll_percent),
                 style::border(focus),
             )]);
             let progress = Paragraph::new(progress).alignment(Alignment::Right);
             frame.render_widget(progress, layout[1]);
         }
     }
     fn state(&self) -> State {
         State::One(StateValue::Usize(self.scroll_percent))
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         use tuirealm::command::Direction;
         match cmd {
             Cmd::Scroll(Direction::Up) => {
                 self.offset = self.offset.saturating_sub(1);
                 self.scroll_percent = Self::scroll_percent(self.offset, self.len, self.height);
                 CmdResult::None
             }
             Cmd::Scroll(Direction::Down) => {
                 if self.scroll_percent < 100 {
                     self.offset = self.offset.saturating_add(1);
                     self.scroll_percent = Self::scroll_percent(self.offset, self.len, self.height);
                 }
                 CmdResult::None
             }
             _ => CmdResult::None,
         }
     }
 }

added src/realm/ui/widget/list.rs

@@ -0,0 +1,375 @@

 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::props::{AttrValue, Attribute, BorderSides, Props};
 use tuirealm::tui::layout::{Constraint, Direction, Layout, Rect};
 use tuirealm::tui::widgets::{Block, Cell, ListState, Row, TableState};
 use tuirealm::{Frame, MockComponent, State, StateValue};
 use crate::realm::ui::layout;
 use crate::realm::ui::state::ItemState;
 use crate::realm::ui::theme::{style, Theme};
 use crate::realm::ui::widget::{utils, Widget, WidgetComponent};
 use super::container::Header;
 use super::label::{self, Label};
 /// A generic item that can be displayed in a table with [`const W: usize`] columns.
 pub trait TableItem<const W: usize> {
     /// Should return fields as table cells.
     fn row(&self, theme: &Theme, highlight: bool) -> [Cell; W];
 }
 /// A generic item that can be displayed in a list.
 pub trait ListItem {
     /// Should return fields as list item.
     fn row(&self, theme: &Theme) -> tuirealm::tui::widgets::ListItem;
 }
 /// Grow behavior of a table column.
 ///
 /// [`tuirealm::tui::widgets::Table`] does only support percental column widths.
 /// A [`ColumnWidth`] is used to specify the grow behaviour of a table column
 /// and a percental column width is calculated based on that.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum ColumnWidth {
     /// A fixed-size column.
     Fixed(u16),
     /// A growable column.
     Grow,
 }
 /// A component that displays a labeled property.
 #[derive(Clone)]
 pub struct Property {
     name: Widget<Label>,
     divider: Widget<Label>,
     value: Widget<Label>,
 }
 impl Property {
     pub fn new(name: Widget<Label>, value: Widget<Label>) -> Self {
         let divider = label::default("");
         Self {
             name,
             divider,
             value,
         }
     }
     pub fn with_divider(mut self, divider: Widget<Label>) -> Self {
         self.divider = divider;
         self
     }
     pub fn name(&self) -> &Widget<Label> {
         &self.name
     }
     pub fn value(&self) -> &Widget<Label> {
         &self.value
     }
 }
 impl WidgetComponent for Property {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             let labels: Vec<Box<dyn MockComponent>> = vec![
                 self.name.clone().to_boxed(),
                 self.divider.clone().to_boxed(),
                 self.value.clone().to_boxed(),
             ];
             let layout = layout::h_stack(labels, area);
             for (mut label, area) in layout {
                 label.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 /// A component that can display lists of labeled properties
 #[derive(Default)]
 pub struct PropertyList {
     properties: Vec<Widget<Property>>,
 }
 impl PropertyList {
     pub fn new(properties: Vec<Widget<Property>>) -> Self {
         Self { properties }
     }
 }
 impl WidgetComponent for PropertyList {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             let properties = self
                 .properties
                 .iter()
                 .map(|property| property.clone().to_boxed() as Box<dyn MockComponent>)
                 .collect();
             let layout = layout::v_stack(properties, area);
             for (mut property, area) in layout {
                 property.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 pub struct PropertyTable {
     properties: Vec<Widget<Property>>,
 }
 impl PropertyTable {
     pub fn new(properties: Vec<Widget<Property>>) -> Self {
         Self { properties }
     }
 }
 impl WidgetComponent for PropertyTable {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         use tuirealm::tui::widgets::Table;
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             let rows = self
                 .properties
                 .iter()
                 .map(|p| Row::new([Cell::from(p.name()), Cell::from(p.value())]));
             let table = Table::new(rows)
                 .widths([Constraint::Percentage(20), Constraint::Percentage(80)].as_ref());
             frame.render_widget(table, area);
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 /// A table component that can display a list of [`TableItem`]s.
 pub struct Table<V, const W: usize>
 where
     V: TableItem<W> + Clone + PartialEq,
 {
     /// Items hold by this model.
     items: Vec<V>,
     /// The table header.
     header: [Widget<Label>; W],
     /// Grow behavior of table columns.
     widths: [ColumnWidth; W],
     /// State that keeps track of the selection.
     state: ItemState,
     /// The current theme.
     theme: Theme,
 }
 impl<V, const W: usize> Table<V, W>
 where
     V: TableItem<W> + Clone + PartialEq,
 {
     pub fn new(
         items: &[V],
         selected: Option<V>,
         header: [Widget<Label>; W],
         widths: [ColumnWidth; W],
         theme: Theme,
     ) -> Self {
         let selected = match selected {
             Some(item) => items.iter().position(|i| i == &item),
             _ => None,
         };
         Self {
             items: items.to_vec(),
             header,
             widths,
             state: ItemState::new(selected, items.len()),
             theme,
         }
     }
 }
 impl<V, const W: usize> WidgetComponent for Table<V, W>
 where
     V: TableItem<W> + Clone + PartialEq,
 {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         let layout = Layout::default()
             .direction(Direction::Vertical)
             .constraints(vec![Constraint::Length(3), Constraint::Min(1)])
             .split(area);
         let widths = utils::column_widths(area, &self.widths, self.theme.tables.spacing);
         let rows: Vec<Row<'_>> = self
             .items
             .iter()
             .enumerate()
             .map(|(index, item)| {
                 Row::new(item.row(
                     &self.theme,
                     match self.state.selected() {
                         Some(selected) => index == selected,
                         None => false,
                     },
                 ))
             })
             .collect();
         let table = tuirealm::tui::widgets::Table::new(rows)
             .block(
                 Block::default()
                     .borders(BorderSides::BOTTOM | BorderSides::LEFT | BorderSides::RIGHT)
                     .border_style(style::border(focus))
                     .border_type(self.theme.border_type),
             )
             .highlight_style(style::highlight())
             .column_spacing(self.theme.tables.spacing)
             .widths(&widths);
         let mut header = Widget::new(Header::new(
             self.header.clone(),
             self.widths,
             self.theme.clone(),
         ));
         header.attr(Attribute::Focus, AttrValue::Flag(focus));
         header.view(frame, layout[0]);
         frame.render_stateful_widget(table, layout[1], &mut TableState::from(&self.state));
     }
     fn state(&self) -> State {
         let selected = self.state.selected().unwrap_or_default();
         let len = self.items.len();
         State::Tup2((StateValue::Usize(selected), StateValue::Usize(len)))
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         use tuirealm::command::Direction;
         match cmd {
             Cmd::Move(Direction::Up) => match self.state.select_previous() {
                 Some(_) => CmdResult::Changed(self.state()),
                 None => CmdResult::None,
             },
             Cmd::Move(Direction::Down) => match self.state.select_next() {
                 Some(_) => CmdResult::Changed(self.state()),
                 None => CmdResult::None,
             },
             Cmd::Submit => match self.state.selected() {
                 Some(_) => CmdResult::Submit(self.state()),
                 None => CmdResult::None,
             },
             _ => CmdResult::None,
         }
     }
 }
 /// A list component that can display [`ListItem`]'s.
 pub struct List<V>
 where
     V: ListItem + Clone + PartialEq,
 {
     /// Items held by this list.
     items: Vec<V>,
     /// State keeps track of the current selection.
     state: ItemState,
     /// The current theme.
     theme: Theme,
 }
 impl<V> List<V>
 where
     V: ListItem + Clone + PartialEq,
 {
     pub fn new(items: &[V], selected: Option<V>, theme: Theme) -> Self {
         let selected = match selected {
             Some(item) => items.iter().position(|i| i == &item),
             _ => None,
         };
         Self {
             items: items.to_vec(),
             state: ItemState::new(selected, items.len()),
             theme,
         }
     }
 }
 impl<V> WidgetComponent for List<V>
 where
     V: ListItem + Clone + PartialEq,
 {
     fn view(&mut self, _properties: &Props, frame: &mut Frame, area: Rect) {
         use tuirealm::tui::widgets::{List, ListItem};
         let rows: Vec<ListItem> = self
             .items
             .iter()
             .map(|item| item.row(&self.theme))
             .collect();
         let list = List::new(rows).highlight_style(style::highlight());
         frame.render_stateful_widget(list, area, &mut ListState::from(&self.state));
     }
     fn state(&self) -> State {
         let selected = self.state.selected().unwrap_or_default();
         let len = self.items.len();
         State::Tup2((StateValue::Usize(selected), StateValue::Usize(len)))
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         use tuirealm::command::Direction;
         match cmd {
             Cmd::Move(Direction::Up) => match self.state.select_previous() {
                 Some(_) => CmdResult::Changed(self.state()),
                 None => CmdResult::None,
             },
             Cmd::Move(Direction::Down) => match self.state.select_next() {
                 Some(_) => CmdResult::Changed(self.state()),
                 None => CmdResult::None,
             },
             Cmd::Submit => match self.state.selected() {
                 Some(_) => CmdResult::Submit(self.state()),
                 None => CmdResult::None,
             },
             _ => CmdResult::None,
         }
     }
 }

added src/realm/ui/widget/utils.rs

@@ -0,0 +1,43 @@

 use tuirealm::tui::layout::{Constraint, Rect};
 use super::list::ColumnWidth;
 /// Calculates `Constraint::Percentage` for each fixed column width in `widths`,
 /// taking into account the available width in `area` and the column spacing given by `spacing`.
 pub fn column_widths(area: Rect, widths: &[ColumnWidth], spacing: u16) -> Vec<Constraint> {
     let total_spacing = spacing.saturating_mul(widths.len() as u16);
     let fixed_width = widths
         .iter()
         .fold(0u16, |total, &width| match width {
             ColumnWidth::Fixed(w) => total + w,
             ColumnWidth::Grow => total,
         })
         .saturating_add(total_spacing);
     let grow_count = widths.iter().fold(0u16, |count, &w| {
         if w == ColumnWidth::Grow {
             count + 1
         } else {
             count
         }
     });
     let grow_width = area
         .width
         .saturating_sub(fixed_width)
         .checked_div(grow_count)
         .unwrap_or(0);
     widths
         .iter()
         .map(|width| match width {
             ColumnWidth::Fixed(w) => {
                 let p: f64 = *w as f64 / area.width as f64 * 100_f64;
                 Constraint::Percentage(p.ceil() as u16)
             }
             ColumnWidth::Grow => {
                 let p: f64 = grow_width as f64 / area.width as f64 * 100_f64;
                 Constraint::Percentage(p.floor() as u16)
             }
         })
         .collect()
 }

deleted src/ui.rs

@@ -1,164 +0,0 @@

 pub mod cob;
 pub mod ext;
 pub mod layout;
 pub mod state;
 pub mod subscription;
 pub mod theme;
 pub mod widget;
 use tuirealm::props::{AttrValue, Attribute};
 use tuirealm::MockComponent;
 use widget::container::{
     AppHeader, AppInfo, Container, GlobalListener, Header, LabeledContainer, Popup, Tabs,
     VerticalLine,
 };
 use widget::context::{Shortcut, Shortcuts};
 use widget::label::{self, Label, Textarea};
 use widget::list::{ColumnWidth, Property, PropertyList, PropertyTable};
 use widget::Widget;
 use theme::{style, Theme};
 use super::context::Context;
 pub fn global_listener() -> Widget<GlobalListener> {
     Widget::new(GlobalListener::default())
 }
 pub fn container_header(theme: &Theme, label: Widget<Label>) -> Widget<Header<1>> {
     let header = Header::new([label], [ColumnWidth::Grow], theme.clone());
     Widget::new(header)
 }
 pub fn container(theme: &Theme, component: Box<dyn MockComponent>) -> Widget<Container> {
     let container = Container::new(component, theme.clone());
     Widget::new(container)
 }
 pub fn labeled_container(
     theme: &Theme,
     title: &str,
     component: Box<dyn MockComponent>,
 ) -> Widget<LabeledContainer> {
     let header = container_header(theme, label::header(&format!(" {title} ")));
     let container = LabeledContainer::new(header, component, theme.clone());
     Widget::new(container)
 }
 pub fn shortcut(theme: &Theme, short: &str, long: &str) -> Widget<Shortcut> {
     let short = label::default(short).style(style::gray());
     let long = label::default(long).style(style::gray_dim());
     let divider = label::default(&theme.icons.whitespace.to_string());
     // TODO: Remove when size constraints are implemented
     let short_w = short.query(Attribute::Width).unwrap().unwrap_size();
     let divider_w = divider.query(Attribute::Width).unwrap().unwrap_size();
     let long_w = long.query(Attribute::Width).unwrap().unwrap_size();
     let width = short_w.saturating_add(divider_w).saturating_add(long_w);
     let shortcut = Shortcut::new(short, divider, long);
     Widget::new(shortcut).height(1).width(width)
 }
 pub fn shortcuts(theme: &Theme, shortcuts: Vec<Widget<Shortcut>>) -> Widget<Shortcuts> {
     let divider =
         label::default(&format!(" {} ", theme.icons.shortcutbar_divider)).style(style::gray_dim());
     let shortcut_bar = Shortcuts::new(shortcuts, divider);
     Widget::new(shortcut_bar).height(1)
 }
 pub fn property(theme: &Theme, name: &str, value: &str) -> Widget<Property> {
     let name = label::property(name);
     let divider = label::default(&format!(" {} ", theme.icons.property_divider));
     let value = label::default(value);
     // TODO: Remove when size constraints are implemented
     let name_w = name.query(Attribute::Width).unwrap().unwrap_size();
     let divider_w = divider.query(Attribute::Width).unwrap().unwrap_size();
     let value_w = value.query(Attribute::Width).unwrap().unwrap_size();
     let width = name_w.saturating_add(divider_w).saturating_add(value_w);
     let property = Property::new(name, value).with_divider(divider);
     Widget::new(property).height(1).width(width)
 }
 pub fn property_list(_theme: &Theme, properties: Vec<Widget<Property>>) -> Widget<PropertyList> {
     let property_list = PropertyList::new(properties);
     Widget::new(property_list)
 }
 pub fn property_table(_theme: &Theme, properties: Vec<Widget<Property>>) -> Widget<PropertyTable> {
     let table = PropertyTable::new(properties);
     Widget::new(table)
 }
 pub fn tabs(_theme: &Theme, tabs: Vec<Widget<Label>>) -> Widget<Tabs> {
     let tabs = Tabs::new(tabs);
     Widget::new(tabs).height(2)
 }
 pub fn app_info(context: &Context) -> Widget<AppInfo> {
     let project = label::default(context.project().name()).style(style::cyan());
     let rid = label::default(&format!(" ({})", context.rid())).style(style::yellow());
     let project_w = project
         .query(Attribute::Width)
         .unwrap_or(AttrValue::Size(0))
         .unwrap_size();
     let rid_w = rid
         .query(Attribute::Width)
         .unwrap_or(AttrValue::Size(0))
         .unwrap_size();
     let info = AppInfo::new(project, rid);
     Widget::new(info).width(project_w.saturating_add(rid_w))
 }
 pub fn app_header(
     context: &Context,
     theme: &Theme,
     nav: Option<Widget<Tabs>>,
 ) -> Widget<AppHeader> {
     let line = label::default(&theme.icons.tab_overline.to_string()).style(style::magenta());
     let line = Widget::new(VerticalLine::new(line));
     let info = app_info(context);
     let header = AppHeader::new(nav, info, line);
     Widget::new(header)
 }
 pub fn info(theme: &Theme, message: &str) -> Widget<Popup> {
     let textarea = Widget::new(Textarea::default()).content(AttrValue::String(message.to_owned()));
     let container = labeled_container(theme, "Info", textarea.to_boxed());
     Widget::new(Popup::new(theme.clone(), container))
         .width(50)
         .height(20)
 }
 pub fn warning(theme: &Theme, message: &str) -> Widget<Popup> {
     let textarea = Widget::new(Textarea::default()).content(AttrValue::String(message.to_owned()));
     let container = labeled_container(theme, "Warning", textarea.to_boxed());
     Widget::new(Popup::new(theme.clone(), container))
         .width(50)
         .height(20)
 }
 pub fn error(theme: &Theme, message: &str) -> Widget<Popup> {
     let textarea = Widget::new(Textarea::default()).content(AttrValue::String(message.to_owned()));
     let container = labeled_container(theme, "Error", textarea.to_boxed());
     Widget::new(Popup::new(theme.clone(), container))
         .width(50)
         .height(20)
 }

deleted src/ui/cob.rs

@@ -1,615 +0,0 @@

 pub mod format;
 use anyhow::anyhow;
 use radicle_surf;
 use tuirealm::props::{Color, Style};
 use tuirealm::tui::text::Line;
 use tuirealm::tui::widgets::Cell;
 use radicle::cob::issue::{self, Issue, IssueId};
 use radicle::cob::patch::{self, Patch, PatchId};
 use radicle::cob::{Label, ObjectId, Timestamp};
 use radicle::issue::Issues;
 use radicle::node::notifications::{Notification, NotificationId, NotificationKind};
 use radicle::node::{Alias, AliasStore};
 use radicle::patch::Patches;
 use radicle::prelude::Did;
 use radicle::storage::git::Repository;
 use radicle::storage::{Oid, ReadRepository, RefUpdate};
 use radicle::{cob, Profile};
 use crate::ui::theme::Theme;
 use crate::ui::widget::list::{ListItem, TableItem};
 use super::widget::label;
 /// An author item that can be used in tables, list or trees.
 ///
 /// Breaks up dependencies to [`Profile`] and [`Repository`] that
 /// would be needed if [`AuthorItem`] would be used directly.
 #[derive(Clone)]
 pub struct AuthorItem {
     /// The author's DID.
     did: Did,
     /// The author's alias
     alias: Option<Alias>,
     /// True if the author is the current user.
     is_you: bool,
 }
 impl AuthorItem {
     pub fn did(&self) -> Did {
         self.did
     }
     pub fn is_you(&self) -> bool {
         self.is_you
     }
     pub fn alias(&self) -> Option<Alias> {
         self.alias.clone()
     }
 }
 /// A patch item that can be used in tables, list or trees.
 ///
 /// Breaks up dependencies to [`Profile`] and [`Repository`] that
 /// would be needed if [`Patch`] would be used directly.
 #[derive(Clone)]
 pub struct PatchItem {
     /// Patch OID.
     id: PatchId,
     /// Patch state.
     state: patch::State,
     /// Patch title.
     title: String,
     /// Author of the latest revision.
     author: AuthorItem,
     /// Head of the latest revision.
     head: Oid,
     /// Lines added by the latest revision.
     added: u16,
     /// Lines removed by the latest revision.
     removed: u16,
     /// Time when patch was opened.
     timestamp: Timestamp,
 }
 impl PatchItem {
     pub fn id(&self) -> &PatchId {
         &self.id
     }
     pub fn state(&self) -> &patch::State {
         &self.state
     }
     pub fn title(&self) -> &String {
         &self.title
     }
     pub fn author(&self) -> &AuthorItem {
         &self.author
     }
     pub fn head(&self) -> &Oid {
         &self.head
     }
     pub fn added(&self) -> u16 {
         self.added
     }
     pub fn removed(&self) -> u16 {
         self.removed
     }
     pub fn timestamp(&self) -> &Timestamp {
         &self.timestamp
     }
 }
 impl PartialEq for PatchItem {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
 }
 impl TryFrom<(&Profile, &Repository, PatchId, Patch)> for PatchItem {
     type Error = anyhow::Error;
     fn try_from(value: (&Profile, &Repository, PatchId, Patch)) -> Result<Self, Self::Error> {
         let (profile, repo, id, patch) = value;
         let (_, rev) = patch.latest();
         let repo = radicle_surf::Repository::open(repo.path())?;
         let base = repo.commit(rev.base())?;
         let head = repo.commit(rev.head())?;
         let diff = repo.diff(base.id, head.id)?;
         let author = patch.author().id;
         Ok(PatchItem {
             id,
             state: patch.state().clone(),
             title: patch.title().into(),
             author: AuthorItem {
                 did: author,
                 alias: profile.aliases().alias(&author),
                 is_you: *patch.author().id == *profile.did(),
             },
             head: rev.head(),
             added: diff.stats().insertions as u16,
             removed: diff.stats().deletions as u16,
             timestamp: rev.timestamp(),
         })
     }
 }
 impl TableItem<8> for PatchItem {
     fn row(&self, _theme: &Theme, highlight: bool) -> [Cell; 8] {
         let (icon, color) = format_patch_state(&self.state);
         if highlight {
             let state = label::reversed(&icon).into();
             let id = label::reversed(&format::cob(&self.id)).into();
             let title = label::reversed(&self.title.clone()).into();
             let author = label::reversed(&format_author(
                 &self.author.did,
                 &self.author.alias,
                 self.author.is_you,
             ))
             .into();
             let head = label::reversed(&format::oid(self.head)).into();
             let added = label::reversed(&format!("+{}", self.added)).into();
             let removed = label::reversed(&format!("-{}", self.removed)).into();
             let updated = label::reversed(&format::timestamp(&self.timestamp)).into();
             [state, id, title, author, head, added, removed, updated]
         } else {
             let state = label::default(&icon)
                 .style(Style::default().fg(color))
                 .into();
             let id = label::id(&format::cob(&self.id)).into();
             let title = label::default(&self.title.clone()).into();
             let author = match &self.author.alias {
                 Some(_) => label::alias(&format_author(
                     &self.author.did,
                     &self.author.alias,
                     self.author.is_you,
                 ))
                 .into(),
                 None => label::did(&format_author(
                     &self.author.did,
                     &self.author.alias,
                     self.author.is_you,
                 ))
                 .into(),
             };
             let head = label::oid(&format::oid(self.head)).into();
             let added = label::positive(&format!("+{}", self.added)).into();
             let removed = label::negative(&format!("-{}", self.removed)).into();
             let updated = label::timestamp(&format::timestamp(&self.timestamp)).into();
             [state, id, title, author, head, added, removed, updated]
         }
     }
 }
 /// An issue item that can be used in tables, list or trees.
 ///
 /// Breaks up dependencies to [`Profile`] and [`Repository`] that
 /// would be needed if [`Issue`] would be used directly.
 #[derive(Clone)]
 pub struct IssueItem {
     /// Issue OID.
     id: IssueId,
     /// Issue state.
     state: issue::State,
     /// Issue title.
     title: String,
     /// Issue author.
     author: AuthorItem,
     /// Issue labels.
     labels: Vec<Label>,
     /// Issue assignees.
     assignees: Vec<AuthorItem>,
     /// Time when issue was opened.
     timestamp: Timestamp,
 }
 impl IssueItem {
     pub fn id(&self) -> &IssueId {
         &self.id
     }
     pub fn state(&self) -> &issue::State {
         &self.state
     }
     pub fn title(&self) -> &String {
         &self.title
     }
     pub fn author(&self) -> &AuthorItem {
         &self.author
     }
     pub fn labels(&self) -> &Vec<Label> {
         &self.labels
     }
     pub fn assignees(&self) -> &Vec<AuthorItem> {
         &self.assignees
     }
     pub fn timestamp(&self) -> &Timestamp {
         &self.timestamp
     }
 }
 impl From<(&Profile, &Repository, IssueId, Issue)> for IssueItem {
     fn from(value: (&Profile, &Repository, IssueId, Issue)) -> Self {
         let (profile, _, id, issue) = value;
         let author = issue.author().id;
         IssueItem {
             id,
             state: *issue.state(),
             title: issue.title().into(),
             author: AuthorItem {
                 did: issue.author().id,
                 alias: profile.aliases().alias(&author),
                 is_you: *issue.author().id == *profile.did(),
             },
             labels: issue.labels().cloned().collect(),
             assignees: issue
                 .assignees()
                 .map(|did| AuthorItem {
                     did: *did,
                     alias: profile.aliases().alias(did),
                     is_you: *did == profile.did(),
                 })
                 .collect::<Vec<_>>(),
             timestamp: issue.timestamp(),
         }
     }
 }
 impl TableItem<7> for IssueItem {
     fn row(&self, _theme: &Theme, highlight: bool) -> [Cell; 7] {
         let (icon, color) = format_issue_state(&self.state);
         if highlight {
             let state = label::reversed(&icon).into();
             let id = label::reversed(&format::cob(&self.id)).into();
             let title = label::reversed(&self.title.clone()).into();
             let author = label::reversed(&format_author(
                 &self.author.did,
                 &self.author.alias,
                 self.author.is_you,
             ))
             .into();
             let labels = label::reversed(&format_labels(&self.labels)).into();
             let assignees = self
                 .assignees
                 .iter()
                 .map(|author| (author.did, author.alias.clone(), author.is_you))
                 .collect::<Vec<_>>();
             let assignees = label::reversed(&format_assignees(&assignees)).into();
             let opened = label::reversed(&format::timestamp(&self.timestamp)).into();
             [state, id, title, author, labels, assignees, opened]
         } else {
             let state = label::default(&icon)
                 .style(Style::default().fg(color))
                 .into();
             let id = label::id(&format::cob(&self.id)).into();
             let title = label::default(&self.title.clone()).into();
             let author = match &self.author.alias {
                 Some(_) => label::alias(&format_author(
                     &self.author.did,
                     &self.author.alias,
                     self.author.is_you,
                 ))
                 .into(),
                 None => label::did(&format_author(
                     &self.author.did,
                     &self.author.alias,
                     self.author.is_you,
                 ))
                 .into(),
             };
             let labels = label::labels(&format_labels(&self.labels)).into();
             let assignees = self
                 .assignees
                 .iter()
                 .map(|author| (author.did, author.alias.clone(), author.is_you))
                 .collect::<Vec<_>>();
             let assignees = label::did(&format_assignees(&assignees)).into();
             let opened = label::timestamp(&format::timestamp(&self.timestamp)).into();
             [state, id, title, author, labels, assignees, opened]
         }
     }
 }
 impl ListItem for IssueItem {
     fn row(&self, theme: &Theme) -> tuirealm::tui::widgets::ListItem {
         let (state, state_color) = format_issue_state(&self.state);
         let lines = vec![
             Line::from(vec![
                 label::default(&state)
                     .style(Style::default().fg(state_color))
                     .into(),
                 label::title(&self.title).into(),
             ]),
             Line::from(vec![
                 label::default("   ").into(),
                 match &self.author.alias {
                     Some(_) => label::alias(&format_author(
                         &self.author.did,
                         &self.author.alias,
                         self.author.is_you,
                     ))
                     .into(),
                     None => label::did(&format_author(
                         &self.author.did,
                         &self.author.alias,
                         self.author.is_you,
                     ))
                     .into(),
                 },
                 label::property_divider(&format!(" {} ", theme.icons.property_divider)).into(),
                 label::timestamp(&format::timestamp(&self.timestamp)).into(),
             ]),
         ];
         tuirealm::tui::widgets::ListItem::new(lines)
     }
 }
 impl PartialEq for IssueItem {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
 }
 //////////////////////////////////////////////////////
 #[derive(Clone)]
 pub enum NotificationKindItem {
     Branch {
         name: String,
         summary: String,
         status: String,
         id: Option<ObjectId>,
     },
     Cob {
         type_name: String,
         summary: String,
         status: String,
         id: Option<ObjectId>,
     },
 }
 impl TryFrom<(&Repository, NotificationKind, RefUpdate)> for NotificationKindItem {
     type Error = anyhow::Error;
     fn try_from(value: (&Repository, NotificationKind, RefUpdate)) -> Result<Self, Self::Error> {
         let (repo, kind, update) = value;
         let issues = Issues::open(repo)?;
         let patches = Patches::open(repo)?;
         match kind {
             NotificationKind::Branch { name } => {
                 let (head, message) = if let Some(head) = update.new() {
                     let message = repo.commit(head)?.summary().unwrap_or_default().to_owned();
                     (Some(head), message)
                 } else {
                     (None, String::new())
                 };
                 let status = match update {
                     RefUpdate::Updated { .. } => "updated",
                     RefUpdate::Created { .. } => "created",
                     RefUpdate::Deleted { .. } => "deleted",
                     RefUpdate::Skipped { .. } => "skipped",
                 };
                 Ok(NotificationKindItem::Branch {
                     name: name.to_string(),
                     summary: message,
                     status: status.to_string(),
                     id: head.map(ObjectId::from),
                 })
             }
             NotificationKind::Cob { type_name, id } => {
                 let (category, summary) = if type_name == *cob::issue::TYPENAME {
                     let issue = issues.get(&id)?.ok_or(anyhow!("missing"))?;
                     (String::from("issue"), issue.title().to_owned())
                 } else if type_name == *cob::patch::TYPENAME {
                     let patch = patches.get(&id)?.ok_or(anyhow!("missing"))?;
                     (String::from("patch"), patch.title().to_owned())
                 } else {
                     (type_name.to_string(), "".to_owned())
                 };
                 let status = match update {
                     RefUpdate::Updated { .. } => "updated",
                     RefUpdate::Created { .. } => "opened",
                     RefUpdate::Deleted { .. } => "deleted",
                     RefUpdate::Skipped { .. } => "skipped",
                 };
                 Ok(NotificationKindItem::Cob {
                     type_name: category.to_string(),
                     summary: summary.to_string(),
                     status: status.to_string(),
                     id: Some(id),
                 })
             }
         }
     }
 }
 #[derive(Clone)]
 pub struct NotificationItem {
     /// Unique notification ID.
     pub id: NotificationId,
     /// Mark this notification as seen.
     pub seen: bool,
     /// Wrapped notification kind.
     pub kind: NotificationKindItem,
     /// Time the update has happened.
     timestamp: Timestamp,
 }
 impl NotificationItem {
     pub fn id(&self) -> &NotificationId {
         &self.id
     }
     pub fn seen(&self) -> bool {
         self.seen
     }
     pub fn kind(&self) -> &NotificationKindItem {
         &self.kind
     }
     pub fn timestamp(&self) -> &Timestamp {
         &self.timestamp
     }
 }
 impl TableItem<7> for NotificationItem {
     fn row(&self, _theme: &Theme, highlight: bool) -> [Cell; 7] {
         let seen = if self.seen {
             label::blank()
         } else {
             label::positive(" ● ")
         };
         let (type_name, summary, status, id) = match &self.kind() {
             NotificationKindItem::Branch {
                 name,
                 summary,
                 status,
                 id: _,
             } => ("branch".to_string(), summary, status, name.to_string()),
             NotificationKindItem::Cob {
                 type_name,
                 summary,
                 status,
                 id,
             } => {
                 let id = id.map(|id| format::cob(&id)).unwrap_or_default();
                 (type_name.to_string(), summary, status, id.to_string())
             }
         };
         let timestamp = if highlight {
             label::reversed(&format::timestamp(&self.timestamp))
         } else {
             label::timestamp(&format::timestamp(&self.timestamp))
         };
         [
             label::default(&format!(" {}", &self.id)).into(),
             seen.into(),
             label::alias(&type_name).into(),
             label::default(summary).into(),
             label::id(&id).into(),
             label::default(status).into(),
             timestamp.into(),
         ]
     }
 }
 impl TryFrom<(&Repository, Notification)> for NotificationItem {
     type Error = anyhow::Error;
     fn try_from(value: (&Repository, Notification)) -> Result<Self, Self::Error> {
         let (repo, notification) = value;
         let kind = NotificationKindItem::try_from((repo, notification.kind, notification.update))?;
         Ok(NotificationItem {
             id: notification.id,
             seen: notification.status.is_read(),
             kind,
             timestamp: notification.timestamp.into(),
         })
     }
 }
 impl PartialEq for NotificationItem {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
 }
 pub fn format_patch_state(state: &patch::State) -> (String, Color) {
     match state {
         patch::State::Open { conflicts: _ } => (" ● ".into(), Color::Green),
         patch::State::Archived => (" ● ".into(), Color::Yellow),
         patch::State::Draft => (" ● ".into(), Color::Gray),
         patch::State::Merged {
             revision: _,
             commit: _,
         } => (" ● ".into(), Color::Cyan),
     }
 }
 pub fn format_author(did: &Did, alias: &Option<Alias>, is_you: bool) -> String {
     let author = match alias {
         Some(alias) => format!("{alias}"),
         None => format::did(did),
     };
     if is_you {
         format!("{} (you)", author)
     } else {
         author
     }
 }
 pub fn format_issue_state(state: &issue::State) -> (String, Color) {
     match state {
         issue::State::Open => (" ● ".into(), Color::Green),
         issue::State::Closed { reason: _ } => (" ● ".into(), Color::Red),
     }
 }
 pub fn format_labels(labels: &[Label]) -> String {
     let mut output = String::new();
     let mut labels = labels.iter().peekable();
     while let Some(label) = labels.next() {
         output.push_str(&label.to_string());
         if labels.peek().is_some() {
             output.push(',');
         }
     }
     output
 }
 pub fn format_assignees(assignees: &[(Did, Option<Alias>, bool)]) -> String {
     let mut output = String::new();
     let mut assignees = assignees.iter().peekable();
     while let Some((assignee, alias, is_you)) = assignees.next() {
         output.push_str(&format_author(assignee, alias, *is_you));
         if assignees.peek().is_some() {
             output.push(',');
         }
     }
     output
 }

deleted src/ui/cob/format.rs

@@ -1,27 +0,0 @@

 use radicle::cob::{ObjectId, Timestamp};
 use radicle::prelude::Did;
 /// Format a git Oid.
 pub fn oid(oid: impl Into<radicle::git::Oid>) -> String {
     format!("{:.7}", oid.into())
 }
 /// Format a COB id.
 pub fn cob(id: &ObjectId) -> String {
     format!("{:.7}", id.to_string())
 }
 /// Format a DID.
 pub fn did(did: &Did) -> String {
     let nid = did.as_key().to_human();
     format!("{}…{}", &nid[..7], &nid[nid.len() - 7..])
 }
 /// Format a timestamp.
 pub fn timestamp(time: &Timestamp) -> String {
     let fmt = timeago::Formatter::new();
     let now = Timestamp::now();
     let duration = std::time::Duration::from_secs(now.as_secs() - time.as_secs());
     fmt.convert(duration)
 }

deleted src/ui/ext.rs

@@ -1,113 +0,0 @@

 use tuirealm::tui::buffer::Buffer;
 use tuirealm::tui::layout::Rect;
 use tuirealm::tui::style::Style;
 use tuirealm::tui::widgets::{BorderType, Borders, Widget};
 pub struct HeaderBlock {
     /// Visible borders
     borders: Borders,
     /// Border style
     border_style: Style,
     /// Type of the border. The default is plain lines but one can choose to have rounded corners
     /// or doubled lines instead.
     border_type: BorderType,
     /// Widget style
     style: Style,
 }
 impl Default for HeaderBlock {
     fn default() -> HeaderBlock {
         HeaderBlock {
             borders: Borders::NONE,
             border_style: Default::default(),
             border_type: BorderType::Plain,
             style: Default::default(),
         }
     }
 }
 impl HeaderBlock {
     pub fn border_style(mut self, style: Style) -> HeaderBlock {
         self.border_style = style;
         self
     }
     pub fn style(mut self, style: Style) -> HeaderBlock {
         self.style = style;
         self
     }
     pub fn borders(mut self, flag: Borders) -> HeaderBlock {
         self.borders = flag;
         self
     }
     pub fn border_type(mut self, border_type: BorderType) -> HeaderBlock {
         self.border_type = border_type;
         self
     }
 }
 impl Widget for HeaderBlock {
     fn render(self, area: Rect, buf: &mut Buffer) {
         if area.area() == 0 {
             return;
         }
         buf.set_style(area, self.style);
         let symbols = BorderType::line_symbols(self.border_type);
         // Sides
         if self.borders.intersects(Borders::LEFT) {
             for y in area.top()..area.bottom() {
                 buf.get_mut(area.left(), y)
                     .set_symbol(symbols.vertical)
                     .set_style(self.border_style);
             }
         }
         if self.borders.intersects(Borders::TOP) {
             for x in area.left()..area.right() {
                 buf.get_mut(x, area.top())
                     .set_symbol(symbols.horizontal)
                     .set_style(self.border_style);
             }
         }
         if self.borders.intersects(Borders::RIGHT) {
             let x = area.right() - 1;
             for y in area.top()..area.bottom() {
                 buf.get_mut(x, y)
                     .set_symbol(symbols.vertical)
                     .set_style(self.border_style);
             }
         }
         if self.borders.intersects(Borders::BOTTOM) {
             let y = area.bottom() - 1;
             for x in area.left()..area.right() {
                 buf.get_mut(x, y)
                     .set_symbol(symbols.horizontal)
                     .set_style(self.border_style);
             }
         }
         // Corners
         if self.borders.contains(Borders::RIGHT | Borders::BOTTOM) {
             buf.get_mut(area.right() - 1, area.bottom() - 1)
                 .set_symbol(symbols.vertical_left)
                 .set_style(self.border_style);
         }
         if self.borders.contains(Borders::RIGHT | Borders::TOP) {
             buf.get_mut(area.right() - 1, area.top())
                 .set_symbol(symbols.top_right)
                 .set_style(self.border_style);
         }
         if self.borders.contains(Borders::LEFT | Borders::BOTTOM) {
             buf.get_mut(area.left(), area.bottom() - 1)
                 .set_symbol(symbols.vertical_right)
                 .set_style(self.border_style);
         }
         if self.borders.contains(Borders::LEFT | Borders::TOP) {
             buf.get_mut(area.left(), area.top())
                 .set_symbol(symbols.top_left)
                 .set_style(self.border_style);
         }
     }
 }

deleted src/ui/layout.rs

@@ -1,278 +0,0 @@

 use tuirealm::props::{AttrValue, Attribute};
 use tuirealm::tui::layout::{Constraint, Direction, Layout, Rect};
 use tuirealm::MockComponent;
 pub struct AppHeader {
     pub nav: Rect,
     pub info: Rect,
     pub line: Rect,
 }
 pub struct FullPage {
     pub navigation: Rect,
     pub component: Rect,
     pub context: Rect,
     pub shortcuts: Rect,
 }
 pub struct DefaultPage {
     pub component: Rect,
     pub context: Rect,
     pub shortcuts: Rect,
 }
 pub struct IssuePage {
     pub header: Rect,
     pub left: Rect,
     pub right: Rect,
     pub context: Rect,
     pub shortcuts: Rect,
 }
 pub fn v_stack(
     widgets: Vec<Box<dyn MockComponent>>,
     area: Rect,
 ) -> Vec<(Box<dyn MockComponent>, Rect)> {
     let constraints = widgets
         .iter()
         .map(|w| {
             Constraint::Length(
                 w.query(Attribute::Height)
                     .unwrap_or(AttrValue::Size(0))
                     .unwrap_size(),
             )
         })
         .collect::<Vec<_>>();
     let layout = Layout::default()
         .direction(Direction::Vertical)
         .constraints(constraints)
         .split(area)
         .to_vec();
     widgets.into_iter().zip(layout).collect()
 }
 pub fn h_stack(
     widgets: Vec<Box<dyn MockComponent>>,
     area: Rect,
 ) -> Vec<(Box<dyn MockComponent>, Rect)> {
     let constraints = widgets
         .iter()
         .map(|w| {
             Constraint::Length(
                 w.query(Attribute::Width)
                     .unwrap_or(AttrValue::Size(0))
                     .unwrap_size(),
             )
         })
         .collect::<Vec<_>>();
     let layout = Layout::default()
         .direction(Direction::Horizontal)
         .constraints(constraints)
         .split(area)
         .to_vec();
     widgets.into_iter().zip(layout).collect()
 }
 pub fn app_header(area: Rect, info_w: u16) -> AppHeader {
     let nav_w = area.width.saturating_sub(info_w);
     let layout = Layout::default()
         .direction(Direction::Vertical)
         .constraints(vec![
             Constraint::Length(1),
             Constraint::Length(1),
             Constraint::Length(1),
         ])
         .split(area);
     let top = Layout::default()
         .direction(Direction::Horizontal)
         .constraints([Constraint::Length(nav_w), Constraint::Length(info_w)].as_ref())
         .split(layout[1]);
     AppHeader {
         nav: top[0],
         info: top[1],
         line: layout[2],
     }
 }
 pub fn full_page(area: Rect, context_h: u16, shortcuts_h: u16) -> FullPage {
     let nav_h = 3u16;
     let margin_h = 1u16;
     let component_h = area
         .height
         .saturating_sub(nav_h.saturating_add(context_h).saturating_add(shortcuts_h));
     let layout = Layout::default()
         .direction(Direction::Vertical)
         .horizontal_margin(margin_h)
         .constraints(
             [
                 Constraint::Length(nav_h),
                 Constraint::Length(component_h),
                 Constraint::Length(context_h),
                 Constraint::Length(shortcuts_h),
             ]
             .as_ref(),
         )
         .split(area);
     FullPage {
         navigation: layout[0],
         component: layout[1],
         context: layout[2],
         shortcuts: layout[3],
     }
 }
 pub fn default_page(area: Rect, context_h: u16, shortcuts_h: u16) -> DefaultPage {
     let margin_h = 1u16;
     let component_h = area
         .height
         .saturating_sub(context_h.saturating_add(shortcuts_h));
     let layout = Layout::default()
         .direction(Direction::Vertical)
         .horizontal_margin(margin_h)
         .constraints(
             [
                 Constraint::Length(component_h),
                 Constraint::Length(context_h),
                 Constraint::Length(shortcuts_h),
             ]
             .as_ref(),
         )
         .split(area);
     DefaultPage {
         component: layout[0],
         context: layout[1],
         shortcuts: layout[2],
     }
 }
 pub fn headerless_page(area: Rect) -> Vec<Rect> {
     let margin_h = 1u16;
     let content_h = area.height.saturating_sub(margin_h);
     Layout::default()
         .direction(Direction::Vertical)
         .horizontal_margin(margin_h)
         .constraints([Constraint::Length(content_h)].as_ref())
         .split(area)
         .to_vec()
 }
 pub fn root_component_with_context(area: Rect, context_h: u16, shortcuts_h: u16) -> Vec<Rect> {
     let content_h = area
         .height
         .saturating_sub(shortcuts_h.saturating_add(context_h));
     Layout::default()
         .direction(Direction::Vertical)
         .constraints(
             [
                 Constraint::Length(content_h),
                 Constraint::Length(context_h),
                 Constraint::Length(shortcuts_h),
             ]
             .as_ref(),
         )
         .split(area)
         .to_vec()
 }
 pub fn centered_label(label_w: u16, area: Rect) -> Rect {
     let label_h = 1u16;
     let spacer_w = area.width.saturating_sub(label_w).saturating_div(2);
     let spacer_h = area.height.saturating_sub(label_h).saturating_div(2);
     let layout = Layout::default()
         .direction(Direction::Vertical)
         .constraints(
             [
                 Constraint::Length(spacer_h),
                 Constraint::Length(label_h),
                 Constraint::Length(spacer_h),
             ]
             .as_ref(),
         )
         .split(area);
     Layout::default()
         .direction(Direction::Horizontal)
         .constraints(
             [
                 Constraint::Length(spacer_w),
                 Constraint::Length(label_w),
                 Constraint::Length(spacer_w),
             ]
             .as_ref(),
         )
         .split(layout[1])[1]
 }
 pub fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
     let popup_layout = Layout::default()
         .direction(Direction::Vertical)
         .constraints(
             [
                 Constraint::Percentage((100 - percent_y) / 2),
                 Constraint::Percentage(percent_y),
                 Constraint::Percentage((100 - percent_y) / 2),
             ]
             .as_ref(),
         )
         .split(r);
     Layout::default()
         .direction(Direction::Horizontal)
         .constraints(
             [
                 Constraint::Percentage((100 - percent_x) / 2),
                 Constraint::Percentage(percent_x),
                 Constraint::Percentage((100 - percent_x) / 2),
             ]
             .as_ref(),
         )
         .split(popup_layout[1])[1]
 }
 pub fn issue_page(area: Rect, shortcuts_h: u16) -> IssuePage {
     let header_h = 3u16;
     let context_h = 1u16;
     let margin_h = 1u16;
     let content_h = area
         .height
         .saturating_sub(header_h.saturating_add(context_h.saturating_add(shortcuts_h)));
     let root = Layout::default()
         .direction(Direction::Vertical)
         .horizontal_margin(margin_h)
         .constraints(
             [
                 Constraint::Length(header_h),
                 Constraint::Length(content_h),
                 Constraint::Length(context_h),
                 Constraint::Length(shortcuts_h),
             ]
             .as_ref(),
         )
         .split(area);
     let split = Layout::default()
         .direction(Direction::Horizontal)
         .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
         .split(root[1]);
     IssuePage {
         header: root[0],
         left: split[0],
         right: split[1],
         context: root[2],
         shortcuts: root[3],
     }
 }

deleted src/ui/state.rs

@@ -1,163 +0,0 @@

 use anyhow::anyhow;
 use tuirealm::tui::widgets::{ListState, TableState};
 use tuirealm::{State, StateValue};
 /// State that holds the index of a selected tab item and the count of all tab items.
 /// The index can be increased and will start at 0, if length was reached.
 #[derive(Clone, Default)]
 pub struct TabState {
     pub selected: u16,
     pub len: u16,
 }
 impl TabState {
     pub fn incr_tab_index(&mut self, rewind: bool) {
         if self.selected + 1 < self.len {
             self.selected += 1;
         } else if rewind {
             self.selected = 0;
         }
     }
 }
 #[derive(Clone)]
 pub struct ItemState {
     selected: Option<usize>,
     len: usize,
 }
 impl ItemState {
     pub fn new(selected: Option<usize>, len: usize) -> Self {
         Self { selected, len }
     }
     pub fn selected(&self) -> Option<usize> {
         if !self.is_empty() {
             self.selected
         } else {
             None
         }
     }
     pub fn select_previous(&mut self) -> Option<usize> {
         let old_index = self.selected();
         let new_index = match old_index {
             Some(0) | None => Some(0),
             Some(selected) => Some(selected.saturating_sub(1)),
         };
         if old_index != new_index {
             self.selected = new_index;
             self.selected()
         } else {
             None
         }
     }
     pub fn select_next(&mut self) -> Option<usize> {
         let old_index = self.selected();
         let new_index = match old_index {
             Some(selected) if selected >= self.len.saturating_sub(1) => {
                 Some(self.len.saturating_sub(1))
             }
             Some(selected) => Some(selected.saturating_add(1)),
             None => Some(0),
         };
         if old_index != new_index {
             self.selected = new_index;
             self.selected()
         } else {
             None
         }
     }
     pub fn len(&self) -> usize {
         self.len
     }
     pub fn is_empty(&self) -> bool {
         self.len == 0
     }
 }
 impl TryFrom<State> for ItemState {
     type Error = anyhow::Error;
     fn try_from(state: State) -> Result<Self, Self::Error> {
         match state {
             State::Tup2((StateValue::Usize(selected), StateValue::Usize(len))) => Ok(Self {
                 selected: Some(selected),
                 len,
             }),
             _ => Err(anyhow!(format!(
                 "Cannot convert into item state: {:?}",
                 state
             ))),
         }
     }
 }
 impl From<&ItemState> for TableState {
     fn from(value: &ItemState) -> Self {
         let mut state = TableState::default();
         state.select(value.selected);
         state
     }
 }
 impl From<&ItemState> for ListState {
     fn from(value: &ItemState) -> Self {
         let mut state = ListState::default();
         state.select(value.selected);
         state
     }
 }
 #[derive(Clone)]
 pub struct FormState {
     focus: Option<usize>,
     len: usize,
 }
 impl FormState {
     pub fn new(focus: Option<usize>, len: usize) -> Self {
         Self { focus, len }
     }
     pub fn focus(&self) -> Option<usize> {
         self.focus
     }
     pub fn focus_previous(&mut self) -> Option<usize> {
         let old_index = self.focus();
         let new_index = match old_index {
             Some(0) | None => Some(0),
             Some(focus) => Some(focus.saturating_sub(1)),
         };
         if old_index != new_index {
             self.focus = new_index;
             self.focus()
         } else {
             None
         }
     }
     pub fn focus_next(&mut self) -> Option<usize> {
         let old_index = self.focus();
         let new_index = match old_index {
             Some(focus) if focus >= self.len.saturating_sub(1) => Some(self.len.saturating_sub(1)),
             Some(focus) => Some(focus.saturating_add(1)),
             None => Some(0),
         };
         if old_index != new_index {
             self.focus = new_index;
             self.focus()
         } else {
             None
         }
     }
 }

deleted src/ui/subscription.rs

@@ -1,22 +0,0 @@

 use tuirealm::event::{Key, KeyEvent, KeyModifiers};
 use tuirealm::SubEventClause;
 pub fn navigation_clause<UserEvent>() -> SubEventClause<UserEvent>
 where
     UserEvent: Clone + Eq + PartialEq + PartialOrd,
 {
     SubEventClause::Keyboard(KeyEvent {
         code: Key::Tab,
         modifiers: KeyModifiers::NONE,
     })
 }
 pub fn quit_clause<UserEvent>(key: Key) -> SubEventClause<UserEvent>
 where
     UserEvent: Clone + Eq + PartialEq + PartialOrd,
 {
     SubEventClause::Keyboard(KeyEvent {
         code: key,
         modifiers: KeyModifiers::NONE,
     })
 }

deleted src/ui/theme.rs

@@ -1,147 +0,0 @@

 use tuirealm::props::BorderType;
 #[derive(Debug, Clone)]
 pub struct Icons {
     pub property_divider: char,
     pub shortcutbar_divider: char,
     pub tab_divider: char,
     pub tab_overline: char,
     pub whitespace: char,
 }
 #[derive(Debug, Clone)]
 pub struct Tables {
     pub spacing: u16,
 }
 /// The Radicle TUI theme. In the future, it might be defined in a JSON
 /// config file.
 #[derive(Debug, Clone)]
 pub struct Theme {
     pub name: String,
     pub icons: Icons,
     pub tables: Tables,
     pub border_type: BorderType,
 }
 impl Default for Theme {
     fn default() -> Theme {
         Theme {
             name: String::from("Default"),
             icons: Icons {
                 property_divider: '∙',
                 shortcutbar_divider: '∙',
                 tab_divider: '|',
                 tab_overline: '▔',
                 whitespace: ' ',
             },
             tables: Tables { spacing: 2 },
             border_type: BorderType::Rounded,
         }
     }
 }
 pub mod style {
     use tuirealm::props::{Color, Style, TextModifiers};
     pub fn reset() -> Style {
         Style::default().fg(Color::Reset)
     }
     pub fn reset_dim() -> Style {
         Style::default()
             .fg(Color::Reset)
             .add_modifier(TextModifiers::DIM)
     }
     pub fn red() -> Style {
         Style::default().fg(Color::Red)
     }
     pub fn green() -> Style {
         Style::default().fg(Color::Green)
     }
     pub fn yellow() -> Style {
         Style::default().fg(Color::Yellow)
     }
     pub fn yellow_dim() -> Style {
         yellow().add_modifier(TextModifiers::DIM)
     }
     pub fn yellow_dim_reversed() -> Style {
         yellow_dim().add_modifier(TextModifiers::REVERSED)
     }
     pub fn blue() -> Style {
         Style::default().fg(Color::Blue)
     }
     pub fn magenta() -> Style {
         Style::default().fg(Color::Magenta)
     }
     pub fn magenta_dim() -> Style {
         Style::default()
             .fg(Color::Magenta)
             .add_modifier(TextModifiers::DIM)
     }
     pub fn cyan() -> Style {
         Style::default().fg(Color::Cyan)
     }
     pub fn lightblue() -> Style {
         Style::default().fg(Color::LightBlue)
     }
     pub fn gray() -> Style {
         Style::default().fg(Color::Gray)
     }
     pub fn gray_dim() -> Style {
         Style::default()
             .fg(Color::Gray)
             .add_modifier(TextModifiers::DIM)
     }
     pub fn darkgray() -> Style {
         Style::default().fg(Color::DarkGray)
     }
     pub fn reversed() -> Style {
         Style::default().add_modifier(TextModifiers::REVERSED)
     }
     pub fn default_reversed() -> Style {
         Style::default()
             .fg(Color::DarkGray)
             // .add_modifier(TextModifiers::DIM)
             .add_modifier(TextModifiers::REVERSED)
     }
     pub fn magenta_reversed() -> Style {
         Style::default()
             .fg(Color::Magenta)
             .add_modifier(TextModifiers::REVERSED)
     }
     pub fn yellow_reversed() -> Style {
         Style::default().fg(Color::DarkGray).bg(Color::Yellow)
     }
     pub fn border(focus: bool) -> Style {
         if focus {
             gray_dim()
         } else {
             darkgray()
         }
     }
     pub fn highlight() -> Style {
         Style::default()
             .fg(Color::Cyan)
             .add_modifier(TextModifiers::REVERSED)
     }
 }

deleted src/ui/widget.rs

@@ -1,102 +0,0 @@

 pub mod container;
 pub mod context;
 pub mod form;
 pub mod label;
 pub mod list;
 mod utils;
 use std::ops::Deref;
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::props::{AttrValue, Attribute, Layout, Props, Style};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{Frame, MockComponent, State};
 pub type BoxedWidget<T> = Box<Widget<T>>;
 pub trait WidgetComponent {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect);
     fn state(&self) -> State;
     fn perform(&mut self, properties: &Props, cmd: Cmd) -> CmdResult;
 }
 #[derive(Clone)]
 pub struct Widget<T: WidgetComponent> {
     component: T,
     properties: Props,
 }
 impl<T: WidgetComponent> Deref for Widget<T> {
     type Target = T;
     fn deref(&self) -> &Self::Target {
         &self.component
     }
 }
 impl<T: WidgetComponent> Widget<T> {
     pub fn new(component: T) -> Self {
         Widget {
             component,
             properties: Props::default(),
         }
     }
     pub fn height(mut self, h: u16) -> Self {
         self.attr(Attribute::Height, AttrValue::Size(h));
         self
     }
     pub fn width(mut self, w: u16) -> Self {
         self.attr(Attribute::Width, AttrValue::Size(w));
         self
     }
     pub fn content(mut self, content: AttrValue) -> Self {
         self.attr(Attribute::Content, content);
         self
     }
     pub fn custom(mut self, key: &'static str, value: AttrValue) -> Self {
         self.attr(Attribute::Custom(key), value);
         self
     }
     pub fn layout(mut self, layout: Layout) -> Self {
         self.attr(Attribute::Layout, AttrValue::Layout(layout));
         self
     }
     pub fn style(mut self, style: Style) -> Self {
         self.attr(Attribute::Style, AttrValue::Style(style));
         self
     }
     pub fn to_boxed(self) -> Box<Self> {
         Box::new(self)
     }
 }
 impl<T: WidgetComponent> MockComponent for Widget<T> {
     fn view(&mut self, frame: &mut Frame, area: Rect) {
         self.component.view(&self.properties, frame, area)
     }
     fn query(&self, attr: Attribute) -> Option<AttrValue> {
         self.properties.get(attr)
     }
     fn attr(&mut self, attr: Attribute, value: AttrValue) {
         self.properties.set(attr, value)
     }
     fn state(&self) -> State {
         self.component.state()
     }
     fn perform(&mut self, cmd: Cmd) -> CmdResult {
         self.component.perform(&self.properties, cmd)
     }
 }

deleted src/ui/widget/common.rs

@@ -1,186 +0,0 @@

 pub mod container;
 pub mod context;
 pub mod form;
 pub mod label;
 pub mod list;
 use tuirealm::props::{AttrValue, Attribute};
 use tuirealm::MockComponent;
 use container::{GlobalListener, Header, LabeledContainer, Tabs};
 use context::{Shortcut, Shortcuts};
 use label::Label;
 use list::{Property, PropertyList};
 use self::container::{AppHeader, AppInfo, Container, Popup, VerticalLine};
 use self::label::Textarea;
 use self::list::{ColumnWidth, PropertyTable};
 use super::Widget;
 use crate::ui::context::Context;
 use crate::ui::theme::Theme;
 pub fn global_listener() -> Widget<GlobalListener> {
     Widget::new(GlobalListener::default())
 }
 pub fn label(content: &str) -> Widget<Label> {
     // TODO: Remove when size constraints are implemented
     let width = content.chars().count() as u16;
     Widget::new(Label)
         .content(AttrValue::String(content.to_string()))
         .height(1)
         .width(width)
 }
 pub fn reversable_label(content: &str) -> Widget<Label> {
     let content = &format!(" {content} ");
     label(content)
 }
 pub fn container_header(theme: &Theme, label: Widget<Label>) -> Widget<Header<1>> {
     let header = Header::new([label], [ColumnWidth::Grow], theme.clone());
     Widget::new(header)
 }
 pub fn container(theme: &Theme, component: Box<dyn MockComponent>) -> Widget<Container> {
     let container = Container::new(component, theme.clone());
     Widget::new(container)
 }
 pub fn labeled_container(
     theme: &Theme,
     title: &str,
     component: Box<dyn MockComponent>,
 ) -> Widget<LabeledContainer> {
     let header = container_header(
         theme,
         label(&format!(" {title} ")).foreground(theme.colors.default_fg),
     );
     let container = LabeledContainer::new(header, component, theme.clone());
     Widget::new(container)
 }
 pub fn shortcut(theme: &Theme, short: &str, long: &str) -> Widget<Shortcut> {
     let short = label(short).foreground(theme.colors.shortcut_short_fg);
     let divider = label(&theme.icons.whitespace.to_string());
     let long = label(long).foreground(theme.colors.shortcut_long_fg);
     // TODO: Remove when size constraints are implemented
     let short_w = short.query(Attribute::Width).unwrap().unwrap_size();
     let divider_w = divider.query(Attribute::Width).unwrap().unwrap_size();
     let long_w = long.query(Attribute::Width).unwrap().unwrap_size();
     let width = short_w.saturating_add(divider_w).saturating_add(long_w);
     let shortcut = Shortcut::new(short, divider, long);
     Widget::new(shortcut).height(1).width(width)
 }
 pub fn shortcuts(theme: &Theme, shortcuts: Vec<Widget<Shortcut>>) -> Widget<Shortcuts> {
     let divider = label(&format!(" {} ", theme.icons.shortcutbar_divider))
         .foreground(theme.colors.shortcutbar_divider_fg);
     let shortcut_bar = Shortcuts::new(shortcuts, divider);
     Widget::new(shortcut_bar).height(1)
 }
 pub fn property(theme: &Theme, name: &str, value: &str) -> Widget<Property> {
     let name = label(name).foreground(theme.colors.property_name_fg);
     let divider = label(&format!(" {} ", theme.icons.property_divider));
     let value = label(value).foreground(theme.colors.default_fg);
     // TODO: Remove when size constraints are implemented
     let name_w = name.query(Attribute::Width).unwrap().unwrap_size();
     let divider_w = divider.query(Attribute::Width).unwrap().unwrap_size();
     let value_w = value.query(Attribute::Width).unwrap().unwrap_size();
     let width = name_w.saturating_add(divider_w).saturating_add(value_w);
     let property = Property::new(name, value).with_divider(divider);
     Widget::new(property).height(1).width(width)
 }
 pub fn property_list(_theme: &Theme, properties: Vec<Widget<Property>>) -> Widget<PropertyList> {
     let property_list = PropertyList::new(properties);
     Widget::new(property_list)
 }
 pub fn property_table(_theme: &Theme, properties: Vec<Widget<Property>>) -> Widget<PropertyTable> {
     let table = PropertyTable::new(properties);
     Widget::new(table)
 }
 pub fn tabs(_theme: &Theme, tabs: Vec<Widget<Label>>) -> Widget<Tabs> {
     let tabs = Tabs::new(tabs);
     Widget::new(tabs).height(2)
 }
 pub fn app_info(context: &Context, theme: &Theme) -> Widget<AppInfo> {
     let project = label(context.project().name()).foreground(theme.colors.app_header_project_fg);
     let rid = label(&format!(" ({})", context.id())).foreground(theme.colors.app_header_rid_fg);
     let project_w = project
         .query(Attribute::Width)
         .unwrap_or(AttrValue::Size(0))
         .unwrap_size();
     let rid_w = rid
         .query(Attribute::Width)
         .unwrap_or(AttrValue::Size(0))
         .unwrap_size();
     let info = AppInfo::new(project, rid);
     Widget::new(info).width(project_w.saturating_add(rid_w))
 }
 pub fn app_header(
     context: &Context,
     theme: &Theme,
     nav: Option<Widget<Tabs>>,
 ) -> Widget<AppHeader> {
     let line =
         label(&theme.icons.tab_overline.to_string()).foreground(theme.colors.tabs_highlighted_fg);
     let line = Widget::new(VerticalLine::new(line));
     let info = app_info(context, theme);
     let header = AppHeader::new(nav, info, line);
     Widget::new(header)
 }
 pub fn info(theme: &Theme, message: &str) -> Widget<Popup> {
     let textarea =
         Widget::new(Textarea::new(theme.clone())).content(AttrValue::String(message.to_owned()));
     let container = labeled_container(theme, "Info", textarea.to_boxed());
     Widget::new(Popup::new(theme.clone(), container))
         .width(50)
         .height(20)
 }
 pub fn warning(theme: &Theme, message: &str) -> Widget<Popup> {
     let textarea =
         Widget::new(Textarea::new(theme.clone())).content(AttrValue::String(message.to_owned()));
     let container = labeled_container(theme, "Warning", textarea.to_boxed());
     Widget::new(Popup::new(theme.clone(), container))
         .width(50)
         .height(20)
 }
 pub fn error(theme: &Theme, message: &str) -> Widget<Popup> {
     let textarea =
         Widget::new(Textarea::new(theme.clone())).content(AttrValue::String(message.to_owned()));
     let container = labeled_container(theme, "Error", textarea.to_boxed());
     Widget::new(Popup::new(theme.clone(), container))
         .width(50)
         .height(20)
 }

deleted src/ui/widget/container.rs

@@ -1,484 +0,0 @@

 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::props::{AttrValue, Attribute, BorderSides, Props, TextModifiers};
 use tuirealm::tui::layout::{Constraint, Direction, Layout, Margin, Rect};
 use tuirealm::tui::widgets::{Block, Cell, Clear, Row};
 use tuirealm::{Frame, MockComponent, State, StateValue};
 use crate::ui::ext::HeaderBlock;
 use crate::ui::layout;
 use crate::ui::state::TabState;
 use crate::ui::theme::{style, Theme};
 use crate::ui::widget::{utils, Widget, WidgetComponent};
 use super::label::Label;
 use super::list::ColumnWidth;
 /// Some user events need to be handled globally (e.g. user presses key `q` to quit
 /// the application). This component can be used in conjunction with SubEventClause
 /// to handle those events.
 #[derive(Default)]
 pub struct GlobalListener {}
 impl WidgetComponent for GlobalListener {
     fn view(&mut self, _properties: &Props, _frame: &mut Frame, _area: Rect) {}
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 /// A vertical separator.
 #[derive(Clone)]
 pub struct VerticalLine {
     line: Widget<Label>,
 }
 impl VerticalLine {
     pub fn new(line: Widget<Label>) -> Self {
         Self { line }
     }
 }
 impl WidgetComponent for VerticalLine {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             // Repeat and render line.
             let overlines = vec![self.line.clone(); area.width as usize];
             let overlines = overlines
                 .iter()
                 .map(|l| l.clone().to_boxed() as Box<dyn MockComponent>)
                 .collect();
             let line_layout = layout::h_stack(overlines, area);
             for (mut line, area) in line_layout {
                 line.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 /// A tab header that displays all labels horizontally aligned and separated
 /// by a divider. Highlights the label defined by the current tab index.
 #[derive(Clone)]
 pub struct Tabs {
     tabs: Vec<Widget<Label>>,
     state: TabState,
 }
 impl Tabs {
     pub fn new(tabs: Vec<Widget<Label>>) -> Self {
         let count = &tabs.len();
         Self {
             tabs,
             state: TabState {
                 selected: 0,
                 len: *count as u16,
             },
         }
     }
 }
 impl WidgetComponent for Tabs {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let selected = self.state().unwrap_one().unwrap_u16();
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             // Render tabs, highlighting the selected tab.
             let mut tabs = vec![];
             for (index, tab) in self.tabs.iter().enumerate() {
                 let mut tab = tab.clone().to_boxed();
                 if index == selected as usize {
                     tab.attr(
                         Attribute::TextProps,
                         AttrValue::TextModifiers(TextModifiers::REVERSED),
                     );
                 }
                 tabs.push(tab.clone().to_boxed() as Box<dyn MockComponent>);
             }
             tabs.push(Widget::new(Label).to_boxed());
             let tab_layout = layout::h_stack(tabs, area);
             for (mut tab, area) in tab_layout {
                 tab.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::One(StateValue::U16(self.state.selected))
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         use tuirealm::command::Direction;
         match cmd {
             Cmd::Move(Direction::Right) => {
                 let prev = self.state.selected;
                 self.state.incr_tab_index(true);
                 if prev != self.state.selected {
                     CmdResult::Changed(self.state())
                 } else {
                     CmdResult::None
                 }
             }
             _ => CmdResult::None,
         }
     }
 }
 /// An application info widget that renders project / branch information
 /// and a separator line. Used in conjunction with [`Tabs`].
 pub struct AppInfo {
     project: Widget<Label>,
     rid: Widget<Label>,
 }
 impl AppInfo {
     pub fn new(project: Widget<Label>, rid: Widget<Label>) -> Self {
         Self { project, rid }
     }
 }
 impl WidgetComponent for AppInfo {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let project_w = self
             .project
             .query(Attribute::Width)
             .unwrap_or(AttrValue::Size(10))
             .unwrap_size();
         let rid_w = self
             .rid
             .query(Attribute::Width)
             .unwrap_or(AttrValue::Size(10))
             .unwrap_size();
         if display {
             let layout = Layout::default()
                 .direction(Direction::Horizontal)
                 .constraints(vec![
                     Constraint::Length(project_w),
                     Constraint::Length(rid_w),
                 ])
                 .split(area);
             self.project.view(frame, layout[0]);
             self.rid.view(frame, layout[1]);
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 /// A common application header that renders project / branch
 /// information and an optional navigation.
 pub struct AppHeader {
     nav: Option<Widget<Tabs>>,
     info: Widget<AppInfo>,
     line: Widget<VerticalLine>,
 }
 impl AppHeader {
     pub fn new(
         nav: Option<Widget<Tabs>>,
         info: Widget<AppInfo>,
         line: Widget<VerticalLine>,
     ) -> Self {
         Self { nav, info, line }
     }
 }
 impl WidgetComponent for AppHeader {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let info_w = self
             .info
             .query(Attribute::Width)
             .unwrap_or(AttrValue::Size(10))
             .unwrap_size();
         if display {
             let layout = layout::app_header(area, info_w);
             if let Some(nav) = self.nav.as_mut() {
                 nav.view(frame, layout.nav);
             }
             self.info.view(frame, layout.info);
             self.line.view(frame, layout.line);
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.nav
             .as_mut()
             .map(|nav| nav.perform(cmd))
             .unwrap_or(CmdResult::None)
     }
 }
 /// A labeled container header.
 pub struct Header<const W: usize> {
     header: [Widget<Label>; W],
     widths: [ColumnWidth; W],
     theme: Theme,
 }
 impl<const W: usize> Header<W> {
     pub fn new(header: [Widget<Label>; W], widths: [ColumnWidth; W], theme: Theme) -> Self {
         Self {
             header,
             widths,
             theme,
         }
     }
 }
 impl<const W: usize> WidgetComponent for Header<W> {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         if display {
             let block = HeaderBlock::default()
                 .borders(BorderSides::all())
                 .border_style(style::border(focus))
                 .border_type(self.theme.border_type);
             frame.render_widget(block, area);
             let layout = Layout::default()
                 .direction(Direction::Vertical)
                 .constraints(vec![Constraint::Min(1)])
                 .vertical_margin(1)
                 .horizontal_margin(1)
                 .split(area);
             let widths = utils::column_widths(area, &self.widths, self.theme.tables.spacing);
             let header: [Cell; W] = self
                 .header
                 .iter()
                 .map(|label| {
                     let cell: Cell = label.into();
                     cell.style(style::reset())
                 })
                 .collect::<Vec<_>>()
                 .try_into()
                 .unwrap();
             let header: Row<'_> = Row::new(header);
             let table = tuirealm::tui::widgets::Table::new(vec![])
                 .column_spacing(self.theme.tables.spacing)
                 .header(header)
                 .widths(&widths);
             frame.render_widget(table, layout[0]);
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 pub struct Container {
     component: Box<dyn MockComponent>,
     theme: Theme,
 }
 impl Container {
     pub fn new(component: Box<dyn MockComponent>, theme: Theme) -> Self {
         Self { component, theme }
     }
 }
 impl WidgetComponent for Container {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         if display {
             // Make some space on the left
             let layout = Layout::default()
                 .direction(Direction::Horizontal)
                 .horizontal_margin(1)
                 .vertical_margin(1)
                 .constraints(vec![Constraint::Length(1), Constraint::Min(0)])
                 .split(area);
             // reverse draw order: child needs to be drawn first?
             self.component
                 .attr(Attribute::Focus, AttrValue::Flag(focus));
             self.component.view(frame, layout[1]);
             let block = Block::default()
                 .borders(BorderSides::ALL)
                 .border_style(style::border(focus))
                 .border_type(self.theme.border_type);
             frame.render_widget(block, area);
         }
     }
     fn state(&self) -> State {
         self.component.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.component.perform(cmd)
     }
 }
 pub struct LabeledContainer {
     header: Widget<Header<1>>,
     component: Box<dyn MockComponent>,
     theme: Theme,
 }
 impl LabeledContainer {
     pub fn new(header: Widget<Header<1>>, component: Box<dyn MockComponent>, theme: Theme) -> Self {
         Self {
             header,
             component,
             theme,
         }
     }
 }
 impl WidgetComponent for LabeledContainer {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         let header_height = self
             .header
             .query(Attribute::Height)
             .unwrap_or(AttrValue::Size(3))
             .unwrap_size();
         if display {
             let layout = Layout::default()
                 .direction(Direction::Vertical)
                 .constraints([Constraint::Length(header_height), Constraint::Min(1)].as_ref())
                 .split(area);
             self.header.attr(Attribute::Focus, AttrValue::Flag(focus));
             self.header.view(frame, layout[0]);
             let block = Block::default()
                 .borders(BorderSides::BOTTOM | BorderSides::LEFT | BorderSides::RIGHT)
                 .border_style(style::border(focus))
                 .border_type(self.theme.border_type);
             frame.render_widget(block.clone(), layout[1]);
             self.component
                 .attr(Attribute::Focus, AttrValue::Flag(focus));
             self.component.view(
                 frame,
                 block.inner(layout[1]).inner(&Margin {
                     vertical: 0,
                     horizontal: 1,
                 }),
             );
         }
     }
     fn state(&self) -> State {
         self.component.state()
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.component.perform(cmd)
     }
 }
 pub struct Popup {
     component: Widget<LabeledContainer>,
 }
 impl Popup {
     pub fn new(_theme: Theme, component: Widget<LabeledContainer>) -> Self {
         Self { component }
     }
 }
 impl WidgetComponent for Popup {
     fn view(&mut self, properties: &Props, frame: &mut Frame, _area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         let width = properties
             .get_or(Attribute::Width, AttrValue::Size(50))
             .unwrap_size();
         let height = properties
             .get_or(Attribute::Height, AttrValue::Size(50))
             .unwrap_size();
         if display {
             let size = frame.size();
             let area = layout::centered_rect(width, height, size);
             frame.render_widget(Clear, area);
             self.component
                 .attr(Attribute::Focus, AttrValue::Flag(focus));
             self.component.view(frame, area);
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         self.component.perform(cmd)
     }
 }

deleted src/ui/widget/context.rs

@@ -1,233 +0,0 @@

 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::props::{AttrValue, Attribute, Props};
 use tuirealm::tui::layout::Rect;
 use tuirealm::{Frame, MockComponent, State};
 use super::label::{self, Label, LabelGroup};
 use crate::ui::layout;
 use crate::ui::theme::{style, Theme};
 use crate::ui::widget::{Widget, WidgetComponent};
 pub enum Progress {
     Percentage(usize),
     Step(usize, usize),
     None,
 }
 impl ToString for Progress {
     fn to_string(&self) -> std::string::String {
         match self {
             Progress::Percentage(value) => format!("{value} %"),
             Progress::Step(step, total) => format!("{step}/{total}"),
             _ => String::new(),
         }
     }
 }
 /// A shortcut that consists of a label displaying the "hotkey", a label that displays
 /// the action and a spacer between them.
 #[derive(Clone)]
 pub struct Shortcut {
     short: Widget<Label>,
     divider: Widget<Label>,
     long: Widget<Label>,
 }
 impl Shortcut {
     pub fn new(short: Widget<Label>, divider: Widget<Label>, long: Widget<Label>) -> Self {
         Self {
             short,
             divider,
             long,
         }
     }
 }
 impl WidgetComponent for Shortcut {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             let labels: Vec<Box<dyn MockComponent>> = vec![
                 self.short.clone().to_boxed(),
                 self.divider.clone().to_boxed(),
                 self.long.clone().to_boxed(),
             ];
             let layout = layout::h_stack(labels, area);
             for (mut shortcut, area) in layout {
                 shortcut.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 /// A shortcut bar that displays multiple shortcuts and separates them with a
 /// divider.
 #[derive(Clone)]
 pub struct Shortcuts {
     shortcuts: Vec<Widget<Shortcut>>,
     divider: Widget<Label>,
 }
 impl Shortcuts {
     pub fn new(shortcuts: Vec<Widget<Shortcut>>, divider: Widget<Label>) -> Self {
         Self { shortcuts, divider }
     }
 }
 impl WidgetComponent for Shortcuts {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             let mut widgets: Vec<Box<dyn MockComponent>> = vec![];
             let mut shortcuts = self.shortcuts.iter_mut().peekable();
             while let Some(shortcut) = shortcuts.next() {
                 if shortcuts.peek().is_some() {
                     widgets.push(shortcut.clone().to_boxed());
                     widgets.push(self.divider.clone().to_boxed())
                 } else {
                     widgets.push(shortcut.clone().to_boxed());
                 }
             }
             let layout = layout::h_stack(widgets, area);
             for (mut widget, area) in layout {
                 widget.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 pub struct ContextBar {
     col_0: Widget<LabelGroup>,
     col_1: Widget<LabelGroup>,
     col_2: Widget<LabelGroup>,
     col_3: Widget<LabelGroup>,
     col_4: Widget<LabelGroup>,
 }
 impl ContextBar {
     pub const PROP_EDIT_MODE: &'static str = "edit-mode";
     pub fn new(
         col_0: Widget<LabelGroup>,
         col_1: Widget<LabelGroup>,
         col_2: Widget<LabelGroup>,
         col_3: Widget<LabelGroup>,
         col_4: Widget<LabelGroup>,
     ) -> Self {
         Self {
             col_0,
             col_1,
             col_2,
             col_3,
             col_4,
         }
     }
 }
 impl WidgetComponent for ContextBar {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let edit_mode = properties
             .get_or(
                 Attribute::Custom(Self::PROP_EDIT_MODE),
                 AttrValue::Flag(false),
             )
             .unwrap_flag();
         let col_0_w = self.col_0.query(Attribute::Width).unwrap().unwrap_size();
         let col_1_w = self.col_1.query(Attribute::Width).unwrap().unwrap_size();
         let col_3_w = self.col_3.query(Attribute::Width).unwrap().unwrap_size();
         let col_4_w = self.col_4.query(Attribute::Width).unwrap().unwrap_size();
         if edit_mode {
             self.col_0.attr(
                 Attribute::Background,
                 AttrValue::Color(style::yellow_reversed().bg.unwrap()),
             )
         }
         if display {
             let content_layout = layout::h_stack(
                 vec![
                     self.col_0.clone().to_boxed(),
                     self.col_1.clone().to_boxed(),
                     self.col_2
                         .clone()
                         .width(
                             area.width
                                 .saturating_sub(col_0_w + col_1_w + col_3_w + col_4_w),
                         )
                         .to_boxed(),
                     self.col_3.clone().to_boxed(),
                     self.col_4.clone().to_boxed(),
                 ],
                 area,
             );
             for (mut component, area) in content_layout {
                 component.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 pub fn bar(
     _theme: &Theme,
     label_0: &str,
     label_1: &str,
     label_2: &str,
     label_3: &str,
     label_4: &str,
 ) -> Widget<ContextBar> {
     let label_0 = label::badge(&format!(" {label_0} "));
     let label_1 = label::default_reversed(&format!(" {label_1} "));
     let label_2 = label::default_reversed(&format!(" {label_2} "));
     let label_3 = label::default_reversed(&format!(" {label_3} "));
     let label_4 = label::default_reversed(&format!(" {label_4} "));
     let label_0 = label::group(&[label_0]);
     let label_1 = label::group(&[label_1]);
     let label_2 = label::group(&[label_2]);
     let label_3 = label::group(&[label_3]);
     let label_4 = label::group(&[label_4]);
     let context_bar = ContextBar::new(label_0, label_1, label_2, label_3, label_4);
     Widget::new(context_bar).height(1)
 }

deleted src/ui/widget/form.rs

@@ -1,268 +0,0 @@

 use std::collections::LinkedList;
 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::tui::layout::{Constraint, Direction, Margin, Rect};
 use tuirealm::{AttrValue, Attribute, Frame, MockComponent, Props, State, StateValue};
 use crate::ui::state::FormState;
 use crate::ui::theme::{style, Theme};
 use crate::ui::widget::{Widget, WidgetComponent};
 use super::container::Container;
 use super::label::{self, Label};
 pub struct TextField {
     input: Widget<Container>,
     placeholder: Widget<Label>,
     show_placeholder: bool,
 }
 impl TextField {
     pub fn new(theme: Theme, title: &str) -> Self {
         // TODO: activate again
         // let input = tui_realm_textarea::TextArea::default()
         //     .wrap(false)
         //     .single_line(true)
         //     .cursor_line_style(Style::reset())
         //     .style(style::reset());
         let input = tui_realm_stdlib::Textarea::default();
         let container = crate::ui::container(&theme, Box::new(input));
         Self {
             input: container,
             placeholder: label::default(title).style(style::gray_dim()),
             show_placeholder: true,
         }
     }
 }
 impl WidgetComponent for TextField {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.input.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.input.view(frame, area);
         if self.show_placeholder {
             let inner = area.inner(&Margin {
                 vertical: 1,
                 horizontal: 2,
             });
             self.placeholder.view(frame, inner);
         }
     }
     fn state(&self) -> State {
         if let State::Vec(values) = self.input.state() {
             let text = match values.get(0) {
                 Some(StateValue::String(line)) => line.clone(),
                 _ => String::new(),
             };
             State::One(StateValue::String(text))
         } else {
             State::None
         }
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         // TODO: activate again
         // use tui_realm_textarea::*;
         // let cmd = match cmd {
         //     Cmd::Custom(Form::CMD_PASTE) => Cmd::Custom(TEXTAREA_CMD_PASTE),
         //     _ => cmd,
         // };
         // let result = self.input.perform(cmd);
         // if let State::Vec(values) = self.input.state() {
         //     if let Some(StateValue::String(input)) = values.first() {
         //         self.show_placeholder = values.len() == 1 && input.is_empty();
         //     } else {
         //         self.show_placeholder = false;
         //     }
         // }
         // result
         CmdResult::None
     }
 }
 pub struct TextArea {
     input: Widget<Container>,
     placeholder: Widget<Label>,
     show_placeholder: bool,
 }
 impl TextArea {
     pub fn new(theme: Theme, title: &str) -> Self {
         // TODO: activate again
         // let input = tui_realm_textarea::TextArea::default()
         //     .wrap(true)
         //     .single_line(false)
         //     .cursor_line_style(Style::reset())
         //     .style(style::reset());
         let input = tui_realm_stdlib::Textarea::default();
         let container = crate::ui::container(&theme, Box::new(input));
         Self {
             input: container,
             placeholder: label::default(title).style(style::gray_dim()),
             show_placeholder: true,
         }
     }
 }
 impl WidgetComponent for TextArea {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         self.input.attr(Attribute::Focus, AttrValue::Flag(focus));
         self.input.view(frame, area);
         if self.show_placeholder {
             let inner = area.inner(&Margin {
                 vertical: 1,
                 horizontal: 2,
             });
             self.placeholder.view(frame, inner);
         }
     }
     fn state(&self) -> State {
         // Fold each input's vector of lines into a single string.
         if let State::Vec(values) = self.input.state() {
             let mut text = String::new();
             let lines = values
                 .iter()
                 .map(|value| match value {
                     StateValue::String(line) => line.clone(),
                     _ => String::new(),
                 })
                 .collect::<Vec<_>>();
             let mut lines = lines.iter().peekable();
             while let Some(line) = lines.next() {
                 text.push_str(line);
                 if lines.peek().is_some() {
                     text.push('\n');
                 }
             }
             State::One(StateValue::String(text))
         } else {
             State::None
         }
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         // TODO: activate again
         // use tui_realm_textarea::*;
         // let cmd = match cmd {
         //     Cmd::Custom(Form::CMD_PASTE) => Cmd::Custom(TEXTAREA_CMD_PASTE),
         //     Cmd::Custom(Form::CMD_NEWLINE) => Cmd::Custom(TEXTAREA_CMD_NEWLINE),
         //     _ => cmd,
         // };
         // let result = self.input.perform(cmd);
         // if let State::Vec(values) = self.input.state() {
         //     if let Some(StateValue::String(input)) = values.first() {
         //         self.show_placeholder = values.len() == 1 && input.is_empty();
         //     } else {
         //         self.show_placeholder = false;
         //     }
         // }
         // result
         CmdResult::None
     }
 }
 pub struct Form {
     // This form's fields: title, tags, assignees, description.
     inputs: Vec<Box<dyn MockComponent>>,
     /// State that holds the current focus etc.
     state: FormState,
 }
 impl Form {
     pub const CMD_FOCUS_PREVIOUS: &'static str = "cmd-focus-previous";
     pub const CMD_FOCUS_NEXT: &'static str = "cmd-focus-next";
     pub const CMD_NEWLINE: &'static str = "cmd-newline";
     pub const CMD_PASTE: &'static str = "cmd-paste";
     pub const PROP_ID: &'static str = "prop-id";
     pub fn new(_theme: Theme, inputs: Vec<Box<dyn MockComponent>>) -> Self {
         let state = FormState::new(Some(0), inputs.len());
         Self { inputs, state }
     }
 }
 impl WidgetComponent for Form {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         use tuirealm::props::Layout;
         // Clear and set current focus
         let focus = self.state.focus().unwrap_or(0);
         for input in &mut self.inputs {
             input.attr(Attribute::Focus, AttrValue::Flag(false));
         }
         if let Some(input) = self.inputs.get_mut(focus) {
             input.attr(Attribute::Focus, AttrValue::Flag(true));
         }
         let layout = Layout::default()
             .direction(Direction::Vertical)
             .constraints(
                 &self
                     .inputs
                     .iter()
                     .map(|_| Constraint::Length(3))
                     .collect::<Vec<_>>(),
             );
         let layout = properties
             .get_or(Attribute::Layout, AttrValue::Layout(layout))
             .unwrap_layout();
         let layout = layout.chunks(area);
         for (index, area) in layout.iter().enumerate().take(self.inputs.len()) {
             if let Some(input) = self.inputs.get_mut(index) {
                 input.view(frame, *area);
             }
         }
     }
     fn state(&self) -> State {
         let states = self
             .inputs
             .iter()
             .map(|input| input.state())
             .collect::<LinkedList<_>>();
         State::Linked(states)
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         match cmd {
             Cmd::Custom(Self::CMD_FOCUS_PREVIOUS) => {
                 self.state.focus_previous();
                 CmdResult::None
             }
             Cmd::Custom(Self::CMD_FOCUS_NEXT) => {
                 self.state.focus_next();
                 CmdResult::None
             }
             Cmd::Submit => CmdResult::Submit(self.state()),
             _ => {
                 let focus = self.state.focus().unwrap_or(0);
                 if let Some(input) = self.inputs.get_mut(focus) {
                     return input.perform(cmd);
                 }
                 CmdResult::None
             }
         }
     }
 }

deleted src/ui/widget/label.rs

@@ -1,352 +0,0 @@

 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::props::{Alignment, AttrValue, Attribute, Color, Props, Style};
 use tuirealm::tui::layout::{Constraint, Direction, Layout, Rect};
 use tuirealm::tui::text::{Line, Span, Text};
 use tuirealm::{Frame, MockComponent, State, StateValue};
 use crate::ui::layout;
 use crate::ui::theme::style;
 use crate::ui::widget::{Widget, WidgetComponent};
 pub fn blank() -> Widget<Label> {
     default("")
 }
 pub fn default(content: &str) -> Widget<Label> {
     // TODO: Remove when size constraints are implemented
     let width = content.chars().count() as u16;
     Widget::new(Label)
         .content(AttrValue::String(content.to_string()))
         .height(1)
         .width(width)
 }
 pub fn reversed(content: &str) -> Widget<Label> {
     default(content).style(style::reversed())
 }
 pub fn default_reversed(content: &str) -> Widget<Label> {
     default(content).style(style::default_reversed())
 }
 pub fn group(labels: &[Widget<Label>]) -> Widget<LabelGroup> {
     let group = LabelGroup::new(labels);
     let width = labels.iter().fold(0, |total, label| {
         total
             + label
                 .query(Attribute::Width)
                 .unwrap_or(AttrValue::Size(0))
                 .unwrap_size()
     });
     Widget::new(group).width(width)
 }
 pub fn reversable(content: &str) -> Widget<Label> {
     let content = &format!(" {content} ");
     default(content)
 }
 pub fn header(content: &str) -> Widget<Label> {
     default(content).style(style::reset_dim())
 }
 pub fn property(content: &str) -> Widget<Label> {
     default(content).style(style::cyan())
 }
 pub fn property_divider(content: &str) -> Widget<Label> {
     default(content).style(style::gray())
 }
 pub fn badge(content: &str) -> Widget<Label> {
     default(content).style(style::magenta_reversed())
 }
 pub fn title(content: &str) -> Widget<Label> {
     default(content)
 }
 pub fn labels(content: &str) -> Widget<Label> {
     default(content).style(style::lightblue())
 }
 pub fn alias(content: &str) -> Widget<Label> {
     default(content).style(style::magenta())
 }
 pub fn did(content: &str) -> Widget<Label> {
     default(content).style(style::magenta_dim())
 }
 pub fn id(content: &str) -> Widget<Label> {
     default(content).style(style::cyan())
 }
 pub fn oid(content: &str) -> Widget<Label> {
     default(content).style(style::lightblue())
 }
 pub fn timestamp(content: &str) -> Widget<Label> {
     default(content).style(style::gray_dim())
 }
 pub fn positive(content: &str) -> Widget<Label> {
     default(content).style(style::green())
 }
 pub fn negative(content: &str) -> Widget<Label> {
     default(content).style(style::red())
 }
 /// A label that can be styled using a foreground color and text modifiers.
 /// Its height is fixed, its width depends on the length of the text it displays.
 #[derive(Clone, Default)]
 pub struct Label;
 impl WidgetComponent for Label {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         use tui_realm_stdlib::Label;
         let content = properties
             .get_or(Attribute::Content, AttrValue::String(String::default()))
             .unwrap_string();
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         let style = properties
             .get_or(Attribute::Style, AttrValue::Style(Style::default()))
             .unwrap_style();
         if display {
             let mut label = Label::default()
                 .foreground(style.fg.unwrap_or(Color::Reset))
                 .background(style.bg.unwrap_or(Color::Reset))
                 .modifiers(style.add_modifier)
                 .text(content);
             label.view(frame, area);
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 impl From<&Widget<Label>> for Span<'_> {
     fn from(label: &Widget<Label>) -> Self {
         let content = label
             .query(Attribute::Content)
             .unwrap_or(AttrValue::String(String::default()))
             .unwrap_string();
         let style = label
             .query(Attribute::Style)
             .unwrap_or(AttrValue::Style(Style::default()))
             .unwrap_style();
         Span::styled(content, style)
     }
 }
 impl From<Widget<Label>> for Span<'_> {
     fn from(label: Widget<Label>) -> Self {
         let content = label
             .query(Attribute::Content)
             .unwrap_or(AttrValue::String(String::default()))
             .unwrap_string();
         let style = label
             .query(Attribute::Style)
             .unwrap_or(AttrValue::Style(Style::default()))
             .unwrap_style();
         Span::styled(content, style)
     }
 }
 impl From<&Widget<Label>> for Text<'_> {
     fn from(label: &Widget<Label>) -> Self {
         let content = label
             .query(Attribute::Content)
             .unwrap_or(AttrValue::String(String::default()))
             .unwrap_string();
         let style = label
             .query(Attribute::Style)
             .unwrap_or(AttrValue::Style(Style::default()))
             .unwrap_style();
         Text::styled(content, style)
     }
 }
 impl From<Widget<Label>> for Text<'_> {
     fn from(label: Widget<Label>) -> Self {
         let content = label
             .query(Attribute::Content)
             .unwrap_or(AttrValue::String(String::default()))
             .unwrap_string();
         let style = label
             .query(Attribute::Style)
             .unwrap_or(AttrValue::Style(Style::default()))
             .unwrap_style();
         Text::styled(content, style)
     }
 }
 #[derive(Clone, Default)]
 pub struct LabelGroup {
     labels: Vec<Widget<Label>>,
 }
 impl LabelGroup {
     pub fn new(labels: &[Widget<Label>]) -> Self {
         Self {
             labels: labels.to_vec(),
         }
     }
 }
 impl WidgetComponent for LabelGroup {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             let mut labels: Vec<Box<dyn MockComponent>> = vec![];
             for label in &self.labels {
                 labels.push(label.clone().to_boxed());
             }
             let layout = layout::h_stack(labels, area);
             for (mut label, area) in layout {
                 label.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 #[derive(Default)]
 pub struct Textarea {
     /// The scroll offset.
     offset: usize,
     /// The current line count.
     len: usize,
     /// The current display height.
     height: usize,
     /// The percentage scrolled.
     scroll_percent: usize,
 }
 impl Textarea {
     pub const PROP_DISPLAY_PROGRESS: &'static str = "display-progress";
     fn scroll_percent(offset: usize, len: usize, height: usize) -> usize {
         if height >= len {
 
         } else {
             let y = offset as f64;
             let h = height as f64;
             let t = len.saturating_sub(1) as f64;
             let v = y / (t - h) * 100_f64;
             std::cmp::max(0, std::cmp::min(100, v as usize))
         }
     }
 }
 impl WidgetComponent for Textarea {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         use tuirealm::tui::widgets::Paragraph;
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         let display_progress = properties
             .get_or(
                 Attribute::Custom(Self::PROP_DISPLAY_PROGRESS),
                 AttrValue::Flag(false),
             )
             .unwrap_flag();
         let content = properties
             .get_or(Attribute::Content, AttrValue::String(String::default()))
             .unwrap_string();
         let layout = Layout::default()
             .direction(Direction::Vertical)
             .constraints([Constraint::Min(1), Constraint::Length(1)])
             .split(area);
         // TODO: replace with `ratatui`'s reflow module when that becomes
         // public: https://github.com/tui-rs-revival/ratatui/pull/9.
         //
         // In the future, there should be highlighting for e.g. Markdown which
         // needs be done before wrapping. So this should rather wrap styled text
         // spans than plain text.
         let body = textwrap::wrap(&content, area.width.saturating_sub(2) as usize);
         self.len = body.len();
         self.height = (layout[0].height - 1) as usize;
         let body: String = body.iter().fold(String::new(), |mut body, line| {
             body.push_str(&format!("{}\n", line));
             body
         });
         let paragraph = Paragraph::new(body)
             .scroll((self.offset as u16, 0))
             .style(style::reset());
         frame.render_widget(paragraph, layout[0]);
         self.scroll_percent = Self::scroll_percent(self.offset, self.len, self.height);
         if display_progress {
             let progress = Line::from(vec![Span::styled(
                 format!("{} %", self.scroll_percent),
                 style::border(focus),
             )]);
             let progress = Paragraph::new(progress).alignment(Alignment::Right);
             frame.render_widget(progress, layout[1]);
         }
     }
     fn state(&self) -> State {
         State::One(StateValue::Usize(self.scroll_percent))
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         use tuirealm::command::Direction;
         match cmd {
             Cmd::Scroll(Direction::Up) => {
                 self.offset = self.offset.saturating_sub(1);
                 self.scroll_percent = Self::scroll_percent(self.offset, self.len, self.height);
                 CmdResult::None
             }
             Cmd::Scroll(Direction::Down) => {
                 if self.scroll_percent < 100 {
                     self.offset = self.offset.saturating_add(1);
                     self.scroll_percent = Self::scroll_percent(self.offset, self.len, self.height);
                 }
                 CmdResult::None
             }
             _ => CmdResult::None,
         }
     }
 }

deleted src/ui/widget/list.rs

@@ -1,375 +0,0 @@

 use tuirealm::command::{Cmd, CmdResult};
 use tuirealm::props::{AttrValue, Attribute, BorderSides, Props};
 use tuirealm::tui::layout::{Constraint, Direction, Layout, Rect};
 use tuirealm::tui::widgets::{Block, Cell, ListState, Row, TableState};
 use tuirealm::{Frame, MockComponent, State, StateValue};
 use crate::ui::layout;
 use crate::ui::state::ItemState;
 use crate::ui::theme::{style, Theme};
 use crate::ui::widget::{utils, Widget, WidgetComponent};
 use super::container::Header;
 use super::label::{self, Label};
 /// A generic item that can be displayed in a table with [`const W: usize`] columns.
 pub trait TableItem<const W: usize> {
     /// Should return fields as table cells.
     fn row(&self, theme: &Theme, highlight: bool) -> [Cell; W];
 }
 /// A generic item that can be displayed in a list.
 pub trait ListItem {
     /// Should return fields as list item.
     fn row(&self, theme: &Theme) -> tuirealm::tui::widgets::ListItem;
 }
 /// Grow behavior of a table column.
 ///
 /// [`tuirealm::tui::widgets::Table`] does only support percental column widths.
 /// A [`ColumnWidth`] is used to specify the grow behaviour of a table column
 /// and a percental column width is calculated based on that.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum ColumnWidth {
     /// A fixed-size column.
     Fixed(u16),
     /// A growable column.
     Grow,
 }
 /// A component that displays a labeled property.
 #[derive(Clone)]
 pub struct Property {
     name: Widget<Label>,
     divider: Widget<Label>,
     value: Widget<Label>,
 }
 impl Property {
     pub fn new(name: Widget<Label>, value: Widget<Label>) -> Self {
         let divider = label::default("");
         Self {
             name,
             divider,
             value,
         }
     }
     pub fn with_divider(mut self, divider: Widget<Label>) -> Self {
         self.divider = divider;
         self
     }
     pub fn name(&self) -> &Widget<Label> {
         &self.name
     }
     pub fn value(&self) -> &Widget<Label> {
         &self.value
     }
 }
 impl WidgetComponent for Property {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             let labels: Vec<Box<dyn MockComponent>> = vec![
                 self.name.clone().to_boxed(),
                 self.divider.clone().to_boxed(),
                 self.value.clone().to_boxed(),
             ];
             let layout = layout::h_stack(labels, area);
             for (mut label, area) in layout {
                 label.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 /// A component that can display lists of labeled properties
 #[derive(Default)]
 pub struct PropertyList {
     properties: Vec<Widget<Property>>,
 }
 impl PropertyList {
     pub fn new(properties: Vec<Widget<Property>>) -> Self {
         Self { properties }
     }
 }
 impl WidgetComponent for PropertyList {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             let properties = self
                 .properties
                 .iter()
                 .map(|property| property.clone().to_boxed() as Box<dyn MockComponent>)
                 .collect();
             let layout = layout::v_stack(properties, area);
             for (mut property, area) in layout {
                 property.view(frame, area);
             }
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 pub struct PropertyTable {
     properties: Vec<Widget<Property>>,
 }
 impl PropertyTable {
     pub fn new(properties: Vec<Widget<Property>>) -> Self {
         Self { properties }
     }
 }
 impl WidgetComponent for PropertyTable {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         use tuirealm::tui::widgets::Table;
         let display = properties
             .get_or(Attribute::Display, AttrValue::Flag(true))
             .unwrap_flag();
         if display {
             let rows = self
                 .properties
                 .iter()
                 .map(|p| Row::new([Cell::from(p.name()), Cell::from(p.value())]));
             let table = Table::new(rows)
                 .widths([Constraint::Percentage(20), Constraint::Percentage(80)].as_ref());
             frame.render_widget(table, area);
         }
     }
     fn state(&self) -> State {
         State::None
     }
     fn perform(&mut self, _properties: &Props, _cmd: Cmd) -> CmdResult {
         CmdResult::None
     }
 }
 /// A table component that can display a list of [`TableItem`]s.
 pub struct Table<V, const W: usize>
 where
     V: TableItem<W> + Clone + PartialEq,
 {
     /// Items hold by this model.
     items: Vec<V>,
     /// The table header.
     header: [Widget<Label>; W],
     /// Grow behavior of table columns.
     widths: [ColumnWidth; W],
     /// State that keeps track of the selection.
     state: ItemState,
     /// The current theme.
     theme: Theme,
 }
 impl<V, const W: usize> Table<V, W>
 where
     V: TableItem<W> + Clone + PartialEq,
 {
     pub fn new(
         items: &[V],
         selected: Option<V>,
         header: [Widget<Label>; W],
         widths: [ColumnWidth; W],
         theme: Theme,
     ) -> Self {
         let selected = match selected {
             Some(item) => items.iter().position(|i| i == &item),
             _ => None,
         };
         Self {
             items: items.to_vec(),
             header,
             widths,
             state: ItemState::new(selected, items.len()),
             theme,
         }
     }
 }
 impl<V, const W: usize> WidgetComponent for Table<V, W>
 where
     V: TableItem<W> + Clone + PartialEq,
 {
     fn view(&mut self, properties: &Props, frame: &mut Frame, area: Rect) {
         let focus = properties
             .get_or(Attribute::Focus, AttrValue::Flag(false))
             .unwrap_flag();
         let layout = Layout::default()
             .direction(Direction::Vertical)
             .constraints(vec![Constraint::Length(3), Constraint::Min(1)])
             .split(area);
         let widths = utils::column_widths(area, &self.widths, self.theme.tables.spacing);
         let rows: Vec<Row<'_>> = self
             .items
             .iter()
             .enumerate()
             .map(|(index, item)| {
                 Row::new(item.row(
                     &self.theme,
                     match self.state.selected() {
                         Some(selected) => index == selected,
                         None => false,
                     },
                 ))
             })
             .collect();
         let table = tuirealm::tui::widgets::Table::new(rows)
             .block(
                 Block::default()
                     .borders(BorderSides::BOTTOM | BorderSides::LEFT | BorderSides::RIGHT)
                     .border_style(style::border(focus))
                     .border_type(self.theme.border_type),
             )
             .highlight_style(style::highlight())
             .column_spacing(self.theme.tables.spacing)
             .widths(&widths);
         let mut header = Widget::new(Header::new(
             self.header.clone(),
             self.widths,
             self.theme.clone(),
         ));
         header.attr(Attribute::Focus, AttrValue::Flag(focus));
         header.view(frame, layout[0]);
         frame.render_stateful_widget(table, layout[1], &mut TableState::from(&self.state));
     }
     fn state(&self) -> State {
         let selected = self.state.selected().unwrap_or_default();
         let len = self.items.len();
         State::Tup2((StateValue::Usize(selected), StateValue::Usize(len)))
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         use tuirealm::command::Direction;
         match cmd {
             Cmd::Move(Direction::Up) => match self.state.select_previous() {
                 Some(_) => CmdResult::Changed(self.state()),
                 None => CmdResult::None,
             },
             Cmd::Move(Direction::Down) => match self.state.select_next() {
                 Some(_) => CmdResult::Changed(self.state()),
                 None => CmdResult::None,
             },
             Cmd::Submit => match self.state.selected() {
                 Some(_) => CmdResult::Submit(self.state()),
                 None => CmdResult::None,
             },
             _ => CmdResult::None,
         }
     }
 }
 /// A list component that can display [`ListItem`]'s.
 pub struct List<V>
 where
     V: ListItem + Clone + PartialEq,
 {
     /// Items held by this list.
     items: Vec<V>,
     /// State keeps track of the current selection.
     state: ItemState,
     /// The current theme.
     theme: Theme,
 }
 impl<V> List<V>
 where
     V: ListItem + Clone + PartialEq,
 {
     pub fn new(items: &[V], selected: Option<V>, theme: Theme) -> Self {
         let selected = match selected {
             Some(item) => items.iter().position(|i| i == &item),
             _ => None,
         };
         Self {
             items: items.to_vec(),
             state: ItemState::new(selected, items.len()),
             theme,
         }
     }
 }
 impl<V> WidgetComponent for List<V>
 where
     V: ListItem + Clone + PartialEq,
 {
     fn view(&mut self, _properties: &Props, frame: &mut Frame, area: Rect) {
         use tuirealm::tui::widgets::{List, ListItem};
         let rows: Vec<ListItem> = self
             .items
             .iter()
             .map(|item| item.row(&self.theme))
             .collect();
         let list = List::new(rows).highlight_style(style::highlight());
         frame.render_stateful_widget(list, area, &mut ListState::from(&self.state));
     }
     fn state(&self) -> State {
         let selected = self.state.selected().unwrap_or_default();
         let len = self.items.len();
         State::Tup2((StateValue::Usize(selected), StateValue::Usize(len)))
     }
     fn perform(&mut self, _properties: &Props, cmd: Cmd) -> CmdResult {
         use tuirealm::command::Direction;
         match cmd {
             Cmd::Move(Direction::Up) => match self.state.select_previous() {
                 Some(_) => CmdResult::Changed(self.state()),
                 None => CmdResult::None,
             },
             Cmd::Move(Direction::Down) => match self.state.select_next() {
                 Some(_) => CmdResult::Changed(self.state()),
                 None => CmdResult::None,
             },
             Cmd::Submit => match self.state.selected() {
                 Some(_) => CmdResult::Submit(self.state()),
                 None => CmdResult::None,
             },
             _ => CmdResult::None,
         }
     }
 }

deleted src/ui/widget/utils.rs

@@ -1,43 +0,0 @@

 use tuirealm::tui::layout::{Constraint, Rect};
 use super::list::ColumnWidth;
 /// Calculates `Constraint::Percentage` for each fixed column width in `widths`,
 /// taking into account the available width in `area` and the column spacing given by `spacing`.
 pub fn column_widths(area: Rect, widths: &[ColumnWidth], spacing: u16) -> Vec<Constraint> {
     let total_spacing = spacing.saturating_mul(widths.len() as u16);
     let fixed_width = widths
         .iter()
         .fold(0u16, |total, &width| match width {
             ColumnWidth::Fixed(w) => total + w,
             ColumnWidth::Grow => total,
         })
         .saturating_add(total_spacing);
     let grow_count = widths.iter().fold(0u16, |count, &w| {
         if w == ColumnWidth::Grow {
             count + 1
         } else {
             count
         }
     });
     let grow_width = area
         .width
         .saturating_sub(fixed_width)
         .checked_div(grow_count)
         .unwrap_or(0);
     widths
         .iter()
         .map(|width| match width {
             ColumnWidth::Fixed(w) => {
                 let p: f64 = *w as f64 / area.width as f64 * 100_f64;
                 Constraint::Percentage(p.ceil() as u16)
             }
             ColumnWidth::Grow => {
                 let p: f64 = grow_width as f64 / area.width as f64 * 100_f64;
                 Constraint::Percentage(p.floor() as u16)
             }
         })
         .collect()
 }