lib: Cleanup app return types — radicle-tui

Clarify an app’s return type by removing the intermediate string representation. This also sunsets the selection mode, that allowed for either returning just an ID or an operation, across all apps.

 use radicle_cli::terminal;
 use radicle_cli::terminal::{Args, Error, Help};
 use self::common::{Mode, RepositoryMode, SelectionMode};
 use self::common::RepositoryMode;
 use crate::commands::tui_inbox::common::InboxOperation;
 use crate::ui::items::notification::filter::{NotificationFilter, SortBy};
 pub const HELP: Help = Help {

 List options
     --mode <MODE>           Set selection mode; see MODE below (default: operation)
     --json                  Return JSON on stderr instead of calling `rad`
     --sort-by <field>       Sort by `id` or `timestamp` (default: timestamp)
     --reverse, -r           Reverse the list
     The MODE argument can be 'operation' or 'id'. 'operation' selects a notification id and
     an operation, whereas 'id' selects a notification id only.
     --json                  Return JSON on stderr instead of calling `rad`
 Other options

 #[derive(Debug, Default, Clone, PartialEq)]
 pub struct ListOptions {
     mode: Mode,
     mode: RepositoryMode,
     filter: NotificationFilter,
     sort_by: SortBy,
     json: bool,

                     };
                 }
                 // list options.
                 Long("mode") | Short('m') if op == OperationName::List => {
                     let val = parser.value()?;
                     let val = val.to_str().unwrap_or_default();
                     let selection_mode = match val {
                         "operation" => SelectionMode::Operation,
                         "id" => SelectionMode::Id,
                         unknown => anyhow::bail!("unknown mode '{}'", unknown),
                     };
                     list_opts.mode = list_opts.mode.with_selection(selection_mode)
                 }
                 Long("reverse") | Short('r') => {
                     reverse = Some(true);
                 }

             return Err(Error::Help.into());
         }
         list_opts.mode = list_opts
             .mode
             .with_repository(repository_mode.unwrap_or_default());
         list_opts.mode = repository_mode.unwrap_or_default();
         list_opts.sort_by = if let Some(field) = field {
             SortBy {
                 field,

                 eprint!("{selection}");
             } else if let Some(selection) = selection {
                 let mut args = vec![];
                 if let Some(operation) = selection.operation {
                     args.push(operation.to_string());
                 }
                 if let Some(id) = selection.ids.first() {
                     args.push(format!("{id}"));
                 if let Some(operation) = selection.operation.clone() {
                     match operation {
                         InboxOperation::Show { id } => {
                             let _ = crate::terminal::run_rad(
                                 Some("inbox"),
                                 &[OsString::from("show"), OsString::from(id.to_string())],
                             );
                         }
                         InboxOperation::Clear { id } => {
                             let _ = crate::terminal::run_rad(
                                 Some("inbox"),
                                 &[OsString::from("clear"), OsString::from(id.to_string())],
                             );
                         }
                     }
                 }
                 let args = args.into_iter().map(OsString::from).collect::<Vec<_>>();
                 let _ = crate::terminal::run_rad(Some("inbox"), &args);
             }
         }
         Operation::Other { args } => {

 use std::fmt::Display;
 use serde::Serialize;
 use radicle::identity::RepoId;
 /// 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 SelectionMode {
     Id,
     #[default]
     Operation,
 }
 use radicle::{identity::RepoId, node::notifications::NotificationId};
 #[derive(Clone, Default, Debug, PartialEq, Eq)]
 pub enum RepositoryMode {

     ByRepo((RepoId, Option<String>)),
 }
 #[derive(Clone, Default, Debug, PartialEq, Eq)]
 pub struct Mode {
     selection: SelectionMode,
     repository: RepositoryMode,
 }
 impl Mode {
     pub fn with_selection(mut self, selection: SelectionMode) -> Self {
         self.selection = selection;
         self
     }
     pub fn with_repository(mut self, repository: RepositoryMode) -> Self {
         self.repository = repository;
         self
     }
     pub fn repository(&self) -> &RepositoryMode {
         &self.repository
     }
 }
 /// 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")
             }
         }
     }
     Show { id: NotificationId },
     Clear { id: NotificationId },
 }

 use std::str::FromStr;
 use std::sync::{Arc, Mutex};
 use std::vec;
 use anyhow::Result;

 use ratatui::{Frame, Viewport};
 use radicle::identity::Project;
 use radicle::node::notifications::NotificationId;
 use radicle::prelude::RepoId;
 use radicle::storage::ReadStorage;
 use radicle::Profile;

 use tui::ui::{BufferedValue, Column, Spacing};
 use tui::{Channel, Exit};
 use super::common::{Mode, RepositoryMode};
 use super::common::RepositoryMode;
 use crate::commands::tui_inbox::common::InboxOperation;
 use crate::ui::items::filter::Filter;
 use crate::ui::items::notification::filter::{NotificationFilter, SortBy};
 use crate::ui::items::notification::Notification;
 type Selection = tui::Selection<NotificationId>;
 type Selection = tui::Selection<InboxOperation>;
 const HELP: &str = r#"# Generic keybindings

 # Specific keybindings
 `enter`:    Select notification (if --mode id)
 `enter`:    Show notification
 `r`:        Reload notifications
 `c`:        Clear notification

     pub profile: Profile,
     pub project: Project,
     pub rid: RepoId,
     pub mode: Mode,
     pub mode: RepositoryMode,
     pub filter: NotificationFilter,
     pub sort_by: SortBy,
 }

                 None
             }
             Message::Quit => Some(Exit { value: None }),
             Message::Exit { operation } => self.selected_notification().map(|issue| Exit {
             Message::Exit { operation } => Some(Exit {
                 value: Some(Selection {
                     operation: operation.map(|op| op.to_string()),
                     ids: vec![issue.id],
                     operation,
                     args: vec![],
                 }),
             }),

             Column::new(Span::raw("ID").bold(), Constraint::Length(8)).hide_medium(),
             Column::new(Span::raw("Summary").bold(), Constraint::Fill(1)),
             Column::new(Span::raw("Repository").bold(), Constraint::Length(16))
                 .skip(*context.mode.repository() != RepositoryMode::All),
                 .skip(context.mode != RepositoryMode::All),
             Column::new(Span::raw("OID").bold(), Constraint::Length(8)).hide_medium(),
             Column::new(Span::raw("Kind").bold(), Constraint::Length(20)).hide_small(),
             Column::new(Span::raw("Change").bold(), Constraint::Length(8)).hide_small(),

             },
         );
         if ui.has_input(|key| key == Key::Enter) {
             ui.send_message(Message::Exit {
                 operation: Some(InboxOperation::Show),
             });
         }
         if ui.has_input(|key| key == Key::Char('c')) {
             ui.send_message(Message::Exit {
                 operation: Some(InboxOperation::Clear),
             });
         }
         if ui.has_input(|key| key == Key::Char('r')) {
             ui.send_message(Message::Reload);
         }
         if let Some(notification) = selected.and_then(|s| notifs.get(s)) {
             if ui.has_input(|key| key == Key::Enter) {
                 ui.send_message(Message::Exit {
                     operation: Some(InboxOperation::Show {
                         id: notification.id,
                     }),
                 });
             }
             if ui.has_input(|key| key == Key::Char('c')) {
                 ui.send_message(Message::Exit {
                     operation: Some(InboxOperation::Clear {
                         id: notification.id,
                     }),
                 });
             }
         }
     }
     fn show_browser_footer(&self, frame: &mut Frame, ui: &mut im::Ui<Message>) {

             Some(Borders::None),
         );
     }
     pub fn selected_notification(&self) -> Option<Notification> {
         let patches = self.notifications.lock().unwrap();
         match self.state.patches.selected() {
             Some(selected) => patches
                 .iter()
                 .filter(|patch| self.state.filter.matches(patch))
                 .collect::<Vec<_>>()
                 .get(selected)
                 .cloned()
                 .cloned(),
             _ => None,
         }
     }
 }
 impl App {

         }
         // Set project name
         let mode = match context.mode.repository() {
         let mode = match context.mode {
             RepositoryMode::ByRepo((rid, _)) => {
                 let name = context.project.name().to_string();
                 context
                     .mode
                     .clone()
                     .with_repository(RepositoryMode::ByRepo((*rid, Some(name))))
                 RepositoryMode::ByRepo((rid, Some(name)))
             }
             _ => context.mode.clone(),
         };
         // Sort by project if all notifications are shown
         if let RepositoryMode::All = mode.repository() {
         if let RepositoryMode::All = mode {
             items.sort_by(|a, b| a.project.cmp(&b.project));
         }
     }

     type Return = Message;
     fn run(&self) -> anyhow::Result<Vec<Self::Return>> {
         let notifications = match self.context.mode.repository() {
         let notifications = match self.context.mode {
             RepositoryMode::All => {
                 let notifs = self.context.profile.notifications_mut()?;
                 let all = notifs.all()?;

                     .collect::<Vec<_>>()
             }
             RepositoryMode::ByRepo((rid, _)) => {
                 let repo = self.context.profile.storage.repository(*rid)?;
                 let repo = self.context.profile.storage.repository(rid)?;
                 let project = repo.project()?;
                 let notifs = self.context.profile.notifications_mut()?;
                 let by_repo = notifs.by_repo(&repo.id, "timestamp")?;

 use radicle_cli::terminal::{Args, Error, Help};
 use crate::cob;
 use crate::commands::tui_issue::common::IssueOperation;
 use crate::ui::TerminalInfo;
 lazy_static! {

                         _ => Some(true),
                     };
                 }
                 // select options.
                 Long("mode") | Short('m') if op == OperationName::List => {
                     let val = parser.value()?;
                     let val = val.to_str().unwrap_or_default();
                     list_opts.mode = match val {
                         "operation" => common::Mode::Operation,
                         "id" => common::Mode::Id,
                         unknown => anyhow::bail!("unknown mode '{unknown}'"),
                     };
                 }
                 Long("all") if op == OperationName::List => {
                     list_opts.filter = list_opts.filter.with_state(None);
                 }

             let context = list::Context {
                 profile,
                 repository,
                 mode: opts.mode,
                 filter: opts.filter.clone(),
             };

 use self::ui::{Browser, BrowserProps};
 use super::common::{IssueOperation, Mode};
 use super::common::IssueOperation;
 type Selection = tui::Selection<IssueId>;
 type Selection = tui::Selection<IssueOperation>;
 pub struct Context {
     pub profile: Profile,
     pub repository: Repository,
     pub mode: Mode,
     pub filter: issue::Filter,
 }

 #[derive(Clone, Debug)]
 pub struct State {
     mode: Mode,
     pages: PageStack<AppPage>,
     browser: BrowserState<IssueItem, IssueItemFilter>,
     preview: PreviewState,

             .collect();
         Ok(Self {
             mode: context.mode.clone(),
             pages: PageStack::new(vec![AppPage::Browser]),
             browser: BrowserState::build(items.clone(), filter, search),
             preview: PreviewState {

 }
 #[derive(Clone, Debug)]
 pub enum RequestedIssueOperation {
     Edit,
     Show,
 }
 #[derive(Clone, Debug)]
 pub enum Message {
     Quit,
     Exit { operation: Option<IssueOperation> },
     ExitFromMode,
     SelectIssue { selected: Option<usize> },
     Exit {
         operation: Option<RequestedIssueOperation>,
     },
     SelectIssue {
         selected: Option<usize>,
     },
     OpenSearch,
     UpdateSearch { value: String },
     UpdateSearch {
         value: String,
     },
     ApplySearch,
     CloseSearch,
     TogglePreview,
     FocusSection { section: Option<Section> },
     SelectComment { selected: Option<Vec<CommentId>> },
     ScrollComment { state: TextViewState },
     FocusSection {
         section: Option<Section>,
     },
     SelectComment {
         selected: Option<Vec<CommentId>>,
     },
     ScrollComment {
         state: TextViewState,
     },
     OpenHelp,
     LeavePage,
     ScrollHelp { state: TextViewState },
     ScrollHelp {
         state: TextViewState,
     },
 }
 impl store::Update<Message> for State {

     fn update(&mut self, message: Message) -> Option<Exit<Selection>> {
         match message {
             Message::Quit => Some(Exit { value: None }),
             Message::Exit { operation } => self.browser.selected_item().map(|issue| Exit {
                 value: Some(Selection {
                     operation: operation.map(|op| op.to_string()),
                     ids: vec![issue.id],
                     args: vec![],
                 }),
             }),
             Message::ExitFromMode => {
                 let operation = match self.mode {
                     Mode::Operation => Some(IssueOperation::Show.to_string()),
                     Mode::Id => None,
             Message::Exit { operation } => {
                 let selected = self.browser.selected_item();
                 let operation = match operation {
                     Some(RequestedIssueOperation::Show) => {
                         selected.map(|issue| IssueOperation::Show { id: issue.id })
                     }
                     Some(RequestedIssueOperation::Edit) => {
                         selected.map(|issue| IssueOperation::Edit { id: issue.id })
                     }
                     _ => None,
                 };
                 self.browser.selected_item().map(|issue| Exit {
                 Some(Exit {
                     value: Some(Selection {
                         operation,
                         ids: vec![issue.id],
                         args: vec![],
                     }),
                 })

             let shortcuts = if state.browser.is_search_shown() {
                 vec![("esc", "cancel"), ("enter", "apply")]
             } else {
                 let mut shortcuts = match state.mode {
                     Mode::Id => vec![("enter", "select")],
                     Mode::Operation => vec![("enter", "show"), ("e", "edit")],
                 };
                 let mut shortcuts = vec![("enter", "show"), ("e", "edit")];
                 if state.section == Some(Section::Browser) {
                     shortcuts = [shortcuts, [("/", "search")].to_vec()].concat()
                 }

             let props = props
                 .and_then(|props| props.inner_ref::<PageProps>())
                 .unwrap_or(&default);
             if props.handle_keys {
                 if let Event::Key(key) = event {
                     match key {
                         Key::Char('q') | Key::Ctrl('c') => Some(Message::Quit),
                         Key::Char('p') => Some(Message::TogglePreview),
                         Key::Char('?') => Some(Message::OpenHelp),
                         Key::Enter => Some(Message::ExitFromMode),
                         Key::Enter => Some(Message::Exit {
                             operation: Some(RequestedIssueOperation::Show),
                         }),
                         Key::Char('e') => Some(Message::Exit {
                             operation: Some(IssueOperation::Edit),
                             operation: Some(RequestedIssueOperation::Edit),
                         }),
                         _ => None,
                     }

 # Specific keybindings
 `Enter`:    Select issue (if --mode id)
 `Enter`:    Show issue
 `e`:        Edit issue
 `p`:        Toggle issue preview

 use radicle_cli::terminal::args::{string, Args, Error, Help};
 use crate::cob::patch;
 use crate::cob::patch::Filter;
 use crate::commands::tui_patch::common::PatchOperation;
 pub const HELP: Help = Help {
     name: "patch",

     --author <did>          Show only patched where the given user is an author
                             (may be specified multiple times)
     The MODE argument can be 'operation' or 'id'. 'operation' selects a patch id and
     an operation, whereas 'id' selects a patch id only.
     --json                  Return JSON on stderr instead of calling `rad`
 Other options

         }
         // Configure list options
         if list_opts.mode == common::Mode::Id {
             list_opts.filter = Filter::default().with_status(None)
         }
         list_opts.json = json;
         // Map local commands. Forward help and ignore `no-forward`.

                 eprint!("{selection}");
             } else if let Some(selection) = selection {
                 if let Some(operation) = selection.operation.clone() {
                     let mut args = vec![operation.to_string()];
                     if let Some(id) = selection.ids.first() {
                         args.push(id.to_string());
                         match operation.as_str() {
                             "review" => {
                                 let opts = ReviewOptions::default();
                                 interface::review(opts, profile, rid, *id).await?;
                             }
                             _ => {
                                 let args = args.into_iter().map(OsString::from).collect::<Vec<_>>();
                                 let _ = crate::terminal::run_rad(Some("patch"), &args);
                             }
                     match operation {
                         PatchOperation::Show { id } => {
                             let _ = crate::terminal::run_rad(
                                 Some("patch"),
                                 &[OsString::from("show"), OsString::from(id.to_string())],
                             );
                         }
                         PatchOperation::Diff { id } => {
                             let _ = crate::terminal::run_rad(
                                 Some("patch"),
                                 &[OsString::from("diff"), OsString::from(id.to_string())],
                             );
                         }
                         PatchOperation::Checkout { id } => {
                             let _ = crate::terminal::run_rad(
                                 Some("patch"),
                                 &[OsString::from("checkout"), OsString::from(id.to_string())],
                             );
                         }
                         PatchOperation::_Review { id } => {
                             let opts = ReviewOptions::default();
                             interface::review(opts, profile, rid, id).await?;
                         }
                     }
                 }