mirror of
https://seed.radicle.dev/rad:z39mP9rQAaGmERfUMPULfPUi473tY.git
synced 2026-11-16 08:20:39 +08:00
880 lines
27 KiB
Rust
880 lines
27 KiB
Rust
#[path = "select/ui.rs"]
|
|
mod ui;
|
|
|
|
use std::collections::{HashMap, HashSet};
|
|
use std::str::FromStr;
|
|
|
|
use anyhow::{bail, Result};
|
|
|
|
use termion::event::Key;
|
|
|
|
use ratatui::layout::Constraint;
|
|
use ratatui::style::Stylize;
|
|
use ratatui::text::{Line, Span, Text};
|
|
|
|
use radicle::cob::thread::CommentId;
|
|
use radicle::git::Oid;
|
|
use radicle::issue::IssueId;
|
|
use radicle::storage::git::Repository;
|
|
use radicle::Profile;
|
|
|
|
use radicle_tui as tui;
|
|
|
|
use tui::store;
|
|
use tui::store::StateValue;
|
|
use tui::ui::span;
|
|
use tui::ui::widget::container::{
|
|
Column, Container, Footer, FooterProps, Header, HeaderProps, SectionGroup, SectionGroupProps,
|
|
SplitContainer, SplitContainerFocus, SplitContainerProps,
|
|
};
|
|
use tui::ui::widget::input::{TextView, TextViewProps};
|
|
use tui::ui::widget::list::{Tree, TreeProps};
|
|
use tui::ui::widget::window::{Page, PageProps, Shortcuts, ShortcutsProps, Window, WindowProps};
|
|
use tui::ui::widget::{PredefinedLayout, ToWidget, Widget};
|
|
use tui::{BoxedAny, Channel, Exit, PageStack};
|
|
|
|
use crate::cob::issue;
|
|
use crate::ui::items::{CommentItem, Filter, IssueItem, IssueItemFilter};
|
|
use crate::ui::widget::{IssueDetails, IssueDetailsProps};
|
|
|
|
use self::ui::{Browser, BrowserProps};
|
|
|
|
use super::common::{IssueOperation, Mode};
|
|
|
|
type Selection = tui::Selection<IssueId>;
|
|
|
|
pub struct Context {
|
|
pub profile: Profile,
|
|
pub repository: Repository,
|
|
pub mode: Mode,
|
|
pub filter: issue::Filter,
|
|
}
|
|
|
|
pub struct App {
|
|
context: Context,
|
|
}
|
|
|
|
#[derive(Clone, Debug, Eq, PartialEq, Hash)]
|
|
pub enum AppPage {
|
|
Browser,
|
|
Help,
|
|
}
|
|
|
|
#[derive(Clone, Default, Debug, Eq, PartialEq)]
|
|
pub enum Section {
|
|
#[default]
|
|
Browser,
|
|
Details,
|
|
Comment,
|
|
}
|
|
|
|
impl TryFrom<usize> for Section {
|
|
type Error = anyhow::Error;
|
|
|
|
fn try_from(value: usize) -> Result<Self, Self::Error> {
|
|
match value {
|
|
0 => Ok(Section::Browser),
|
|
1 => Ok(Section::Details),
|
|
2 => Ok(Section::Comment),
|
|
_ => bail!("Unknown section index: {}", value),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<Section> for usize {
|
|
fn from(section: Section) -> Self {
|
|
match section {
|
|
Section::Browser => 0,
|
|
Section::Details => 1,
|
|
Section::Comment => 2,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct BrowserState {
|
|
items: Vec<IssueItem>,
|
|
selected: Option<usize>,
|
|
filter: IssueItemFilter,
|
|
search: store::StateValue<String>,
|
|
show_search: bool,
|
|
}
|
|
|
|
impl BrowserState {
|
|
pub fn issues(&self) -> Vec<IssueItem> {
|
|
self.issues_ref().into_iter().cloned().collect()
|
|
}
|
|
|
|
pub fn issues_ref(&self) -> Vec<&IssueItem> {
|
|
self.items
|
|
.iter()
|
|
.filter(|patch| self.filter.matches(patch))
|
|
.collect()
|
|
}
|
|
|
|
pub fn selected_issue(&self) -> Option<&IssueItem> {
|
|
self.selected
|
|
.and_then(|selected| self.issues_ref().get(selected).copied())
|
|
}
|
|
}
|
|
|
|
impl BrowserState {
|
|
pub fn show_search(&mut self) {
|
|
self.show_search = true;
|
|
}
|
|
|
|
pub fn hide_search(&mut self) {
|
|
self.show_search = false;
|
|
}
|
|
|
|
pub fn apply_search(&mut self) {
|
|
self.search.apply();
|
|
}
|
|
|
|
pub fn reset_search(&mut self) {
|
|
self.search.reset();
|
|
}
|
|
|
|
pub fn search(&mut self, value: String) {
|
|
self.search.write(value);
|
|
self.filter_items();
|
|
}
|
|
|
|
pub fn filter_items(&mut self) {
|
|
self.filter = IssueItemFilter::from_str(&self.search.read()).unwrap_or_default();
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct CommentState {
|
|
/// Current text view cursor.
|
|
cursor: (usize, usize),
|
|
}
|
|
|
|
impl CommentState {
|
|
pub fn reset_cursor(&mut self) {
|
|
self.cursor = (0, 0);
|
|
}
|
|
|
|
pub fn update_cursor(&mut self, cursor: (usize, usize)) {
|
|
self.cursor = cursor;
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct PreviewState {
|
|
/// If preview is visible.
|
|
show: bool,
|
|
/// Currently selected issue item.
|
|
issue: Option<IssueItem>,
|
|
/// Tree selection per issue.
|
|
selected_comments: HashMap<IssueId, Vec<CommentId>>,
|
|
/// State of currently selected comment
|
|
comment: CommentState,
|
|
}
|
|
|
|
impl PreviewState {
|
|
pub fn root_comments(&self) -> Vec<CommentItem> {
|
|
self.issue
|
|
.as_ref()
|
|
.map(|item| item.root_comments())
|
|
.unwrap_or_default()
|
|
}
|
|
|
|
pub fn selected_comment(&self) -> Option<&CommentItem> {
|
|
self.issue.as_ref().and_then(|item| {
|
|
self.selected_comments
|
|
.get(&item.id)
|
|
.and_then(|selection| selection.last().copied())
|
|
.and_then(|comment_id| {
|
|
item.comments
|
|
.iter()
|
|
.filter(|item| item.id == comment_id)
|
|
.collect::<Vec<_>>()
|
|
.first()
|
|
.cloned()
|
|
})
|
|
})
|
|
}
|
|
|
|
pub fn selected_comment_ids(&self) -> Vec<String> {
|
|
self.issue
|
|
.as_ref()
|
|
.and_then(|item| self.selected_comments.get(&item.id))
|
|
.map(|selected| selected.iter().map(|oid| oid.to_string()).collect())
|
|
.unwrap_or_default()
|
|
}
|
|
|
|
pub fn opened_comments(&self) -> HashSet<Vec<String>> {
|
|
let mut opened = HashSet::new();
|
|
if let Some(item) = &self.issue {
|
|
for comment in item.root_comments() {
|
|
append_opened(&mut opened, vec![], comment.clone());
|
|
}
|
|
}
|
|
opened
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct HelpState {
|
|
scroll: usize,
|
|
cursor: (usize, usize),
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct State {
|
|
mode: Mode,
|
|
pages: PageStack<AppPage>,
|
|
browser: BrowserState,
|
|
preview: PreviewState,
|
|
section: Option<Section>,
|
|
help: HelpState,
|
|
}
|
|
|
|
impl TryFrom<&Context> for State {
|
|
type Error = anyhow::Error;
|
|
|
|
fn try_from(context: &Context) -> Result<Self, Self::Error> {
|
|
let issues = issue::all(&context.profile, &context.repository)?;
|
|
let search = StateValue::new(context.filter.to_string());
|
|
let filter = IssueItemFilter::from_str(&search.read()).unwrap_or_default();
|
|
|
|
// Convert into UI items
|
|
let mut items = vec![];
|
|
for issue in issues {
|
|
if let Ok(item) = IssueItem::new(&context.profile, issue.clone()) {
|
|
items.push(item);
|
|
}
|
|
}
|
|
items.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
|
|
|
|
// Pre-select first comment
|
|
let mut selected_comments = HashMap::new();
|
|
for item in &items {
|
|
selected_comments.insert(
|
|
item.id,
|
|
item.root_comments()
|
|
.first()
|
|
.map(|comment| vec![comment.id])
|
|
.unwrap_or_default(),
|
|
);
|
|
}
|
|
|
|
Ok(Self {
|
|
mode: context.mode.clone(),
|
|
pages: PageStack::new(vec![AppPage::Browser]),
|
|
browser: BrowserState {
|
|
items: items.clone(),
|
|
selected: Some(0),
|
|
filter,
|
|
search,
|
|
show_search: false,
|
|
},
|
|
preview: PreviewState {
|
|
show: false,
|
|
issue: items.first().cloned(),
|
|
selected_comments,
|
|
comment: CommentState { cursor: (0, 0) },
|
|
},
|
|
section: Some(Section::Browser),
|
|
help: HelpState {
|
|
scroll: 0,
|
|
cursor: (0, 0),
|
|
},
|
|
})
|
|
}
|
|
}
|
|
|
|
pub enum Message {
|
|
Quit,
|
|
Exit {
|
|
operation: Option<IssueOperation>,
|
|
},
|
|
ExitFromMode,
|
|
SelectIssue {
|
|
selected: Option<usize>,
|
|
},
|
|
OpenSearch,
|
|
UpdateSearch {
|
|
value: String,
|
|
},
|
|
ApplySearch,
|
|
CloseSearch,
|
|
TogglePreview,
|
|
FocusSection {
|
|
section: Option<Section>,
|
|
},
|
|
SelectComment {
|
|
selected: Option<Vec<CommentId>>,
|
|
},
|
|
ScrollComment {
|
|
cursor: (usize, usize),
|
|
},
|
|
OpenHelp,
|
|
LeavePage,
|
|
ScrollHelp {
|
|
scroll: usize,
|
|
cursor: (usize, usize),
|
|
},
|
|
}
|
|
|
|
impl store::State<Selection> for State {
|
|
type Message = Message;
|
|
|
|
fn update(&mut self, message: Message) -> Option<Exit<Selection>> {
|
|
match message {
|
|
Message::Quit => Some(Exit { value: None }),
|
|
Message::Exit { operation } => self.browser.selected_issue().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,
|
|
};
|
|
|
|
self.browser.selected_issue().map(|issue| Exit {
|
|
value: Some(Selection {
|
|
operation,
|
|
ids: vec![issue.id],
|
|
args: vec![],
|
|
}),
|
|
})
|
|
}
|
|
Message::SelectIssue { selected } => {
|
|
self.browser.selected = selected;
|
|
self.preview.issue = self.browser.selected_issue().cloned();
|
|
self.preview.comment.reset_cursor();
|
|
None
|
|
}
|
|
Message::TogglePreview => {
|
|
self.preview.show = !self.preview.show;
|
|
self.section = Some(Section::Browser);
|
|
None
|
|
}
|
|
Message::FocusSection { section } => {
|
|
self.section = section;
|
|
None
|
|
}
|
|
Message::SelectComment { selected } => {
|
|
if let Some(item) = &self.preview.issue {
|
|
self.preview
|
|
.selected_comments
|
|
.insert(item.id, selected.unwrap_or(vec![]));
|
|
}
|
|
self.preview.comment.reset_cursor();
|
|
None
|
|
}
|
|
Message::ScrollComment { cursor } => {
|
|
self.preview.comment.update_cursor(cursor);
|
|
None
|
|
}
|
|
Message::OpenSearch => {
|
|
self.browser.show_search();
|
|
None
|
|
}
|
|
Message::UpdateSearch { value } => {
|
|
self.browser.search(value);
|
|
|
|
if let Some(selected) = self.browser.selected {
|
|
if selected > self.browser.issues().len() {
|
|
self.browser.selected = Some(0);
|
|
self.preview.issue = self.browser.issues().first().cloned();
|
|
} else {
|
|
self.preview.issue = self.browser.issues().get(selected).cloned();
|
|
}
|
|
} else {
|
|
self.preview.issue = None;
|
|
}
|
|
|
|
None
|
|
}
|
|
Message::ApplySearch => {
|
|
self.browser.hide_search();
|
|
self.browser.apply_search();
|
|
None
|
|
}
|
|
Message::CloseSearch => {
|
|
self.browser.hide_search();
|
|
self.browser.reset_search();
|
|
self.browser.filter_items();
|
|
|
|
self.preview.issue = self.browser.selected_issue().cloned();
|
|
self.preview.comment.reset_cursor();
|
|
None
|
|
}
|
|
Message::OpenHelp => {
|
|
self.pages.push(AppPage::Help);
|
|
None
|
|
}
|
|
Message::LeavePage => {
|
|
self.pages.pop();
|
|
None
|
|
}
|
|
Message::ScrollHelp { scroll, cursor } => {
|
|
self.help.scroll = scroll;
|
|
self.help.cursor = cursor;
|
|
None
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl App {
|
|
pub fn new(context: Context) -> Self {
|
|
Self { context }
|
|
}
|
|
|
|
pub async fn run(&self) -> Result<Option<Selection>> {
|
|
let channel = Channel::default();
|
|
let state = State::try_from(&self.context)?;
|
|
let tx = channel.tx.clone();
|
|
|
|
let window = Window::default()
|
|
.page(AppPage::Browser, browser_page(&channel))
|
|
.page(AppPage::Help, help_page(&channel))
|
|
.to_widget(tx.clone())
|
|
.on_update(|state| {
|
|
WindowProps::default()
|
|
.current_page(state.pages.peek().unwrap_or(&AppPage::Browser).clone())
|
|
.to_boxed_any()
|
|
.into()
|
|
});
|
|
|
|
tui::run(channel, state, window).await
|
|
}
|
|
}
|
|
|
|
fn browser_page(channel: &Channel<Message>) -> Widget<State, Message> {
|
|
let tx = channel.tx.clone();
|
|
|
|
let shortcuts = Shortcuts::default()
|
|
.to_widget(tx.clone())
|
|
.on_update(|state: &State| {
|
|
let shortcuts = if state.browser.show_search {
|
|
vec![("esc", "cancel"), ("enter", "apply")]
|
|
} else {
|
|
let mut shortcuts = match state.mode {
|
|
Mode::Id => vec![("enter", "select")],
|
|
Mode::Operation => vec![("enter", "show"), ("e", "edit")],
|
|
};
|
|
if state.section == Some(Section::Browser) {
|
|
shortcuts = [shortcuts, [("/", "search")].to_vec()].concat()
|
|
}
|
|
[shortcuts, [("p", "preview"), ("?", "help")].to_vec()].concat()
|
|
};
|
|
|
|
ShortcutsProps::default()
|
|
.shortcuts(&shortcuts)
|
|
.to_boxed_any()
|
|
.into()
|
|
});
|
|
|
|
Page::default()
|
|
.content(
|
|
SectionGroup::default()
|
|
.section(browser(channel))
|
|
.section(issue(channel))
|
|
.section(comment(channel))
|
|
.to_widget(tx.clone())
|
|
.on_event(|_, vs, _| {
|
|
Some(Message::FocusSection {
|
|
section: vs.and_then(|vs| {
|
|
vs.unwrap_section_group()
|
|
.and_then(|sgs| sgs.focus)
|
|
.map(|s| s.try_into().unwrap_or_default())
|
|
}),
|
|
})
|
|
})
|
|
.on_update(|state: &State| {
|
|
SectionGroupProps::default()
|
|
.handle_keys(state.preview.show && !state.browser.show_search)
|
|
.layout(PredefinedLayout::Expandable3 {
|
|
left_only: !state.preview.show,
|
|
})
|
|
.focus(state.section.as_ref().map(|s| s.clone().into()))
|
|
.to_boxed_any()
|
|
.into()
|
|
}),
|
|
)
|
|
.shortcuts(shortcuts)
|
|
.to_widget(tx.clone())
|
|
.on_event(|key, _, props| {
|
|
let default = PageProps::default();
|
|
let props = props
|
|
.and_then(|props| props.inner_ref::<PageProps>())
|
|
.unwrap_or(&default);
|
|
|
|
if props.handle_keys {
|
|
match key {
|
|
Key::Esc | Key::Ctrl('c') => Some(Message::Quit),
|
|
Key::Char('p') => Some(Message::TogglePreview),
|
|
Key::Char('?') => Some(Message::OpenHelp),
|
|
Key::Char('\n') => Some(Message::ExitFromMode),
|
|
Key::Char('e') => Some(Message::Exit {
|
|
operation: Some(IssueOperation::Edit),
|
|
}),
|
|
_ => None,
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.on_update(|state: &State| {
|
|
PageProps::default()
|
|
.handle_keys(!state.browser.show_search)
|
|
.to_boxed_any()
|
|
.into()
|
|
})
|
|
}
|
|
|
|
fn browser(channel: &Channel<Message>) -> Widget<State, Message> {
|
|
let tx = channel.tx.clone();
|
|
|
|
Browser::new(tx.clone())
|
|
.to_widget(tx.clone())
|
|
.on_update(|state| BrowserProps::from(state).to_boxed_any().into())
|
|
}
|
|
|
|
fn issue(channel: &Channel<Message>) -> Widget<State, Message> {
|
|
let tx = channel.tx.clone();
|
|
|
|
SplitContainer::default()
|
|
.top(issue_details(channel))
|
|
.bottom(comment_tree(channel))
|
|
.to_widget(tx.clone())
|
|
.on_update(|_| {
|
|
SplitContainerProps::default()
|
|
.heights([Constraint::Length(5), Constraint::Min(1)])
|
|
.split_focus(SplitContainerFocus::Bottom)
|
|
.to_boxed_any()
|
|
.into()
|
|
})
|
|
}
|
|
|
|
fn issue_details(channel: &Channel<Message>) -> Widget<State, Message> {
|
|
let tx = channel.tx.clone();
|
|
|
|
IssueDetails::default()
|
|
.to_widget(tx.clone())
|
|
.on_update(|state: &State| {
|
|
IssueDetailsProps::default()
|
|
.issue(state.preview.issue.clone())
|
|
.to_boxed_any()
|
|
.into()
|
|
})
|
|
}
|
|
|
|
fn comment_tree(channel: &Channel<Message>) -> Widget<State, Message> {
|
|
let tx = channel.tx.clone();
|
|
|
|
Tree::<State, Message, CommentItem, String>::default()
|
|
.to_widget(tx.clone())
|
|
.on_event(|_, s, _| {
|
|
Some(Message::SelectComment {
|
|
selected: s.and_then(|s| {
|
|
s.unwrap_tree()
|
|
.map(|tree| tree.iter().map(|id| Oid::from_str(id).unwrap()).collect())
|
|
}),
|
|
})
|
|
})
|
|
.on_update(|state| {
|
|
let root = &state.preview.root_comments();
|
|
let opened = &state.preview.opened_comments();
|
|
let selected = &state.preview.selected_comment_ids();
|
|
|
|
TreeProps::<CommentItem, String>::default()
|
|
.items(root.to_vec())
|
|
.selected(Some(selected))
|
|
.opened(Some(opened.clone()))
|
|
.to_boxed_any()
|
|
.into()
|
|
})
|
|
}
|
|
|
|
fn comment(channel: &Channel<Message>) -> Widget<State, Message> {
|
|
let tx = channel.tx.clone();
|
|
|
|
Container::default()
|
|
.content(
|
|
TextView::default()
|
|
.to_widget(tx.clone())
|
|
.on_event(|_, vs, _| {
|
|
let textview = vs.and_then(|p| p.unwrap_textview()).unwrap_or_default();
|
|
Some(Message::ScrollComment {
|
|
cursor: textview.cursor,
|
|
})
|
|
})
|
|
.on_update(|state: &State| {
|
|
let comment = state.preview.selected_comment();
|
|
let body: String = comment
|
|
.map(|comment| comment.body.clone())
|
|
.unwrap_or_default();
|
|
let reactions = comment
|
|
.map(|comment| {
|
|
let reactions = comment.accumulated_reactions().iter().fold(
|
|
String::new(),
|
|
|all, (r, acc)| {
|
|
if *acc > 1_usize {
|
|
[all, format!("{}{} ", r, acc)].concat()
|
|
} else {
|
|
[all, format!("{} ", r)].concat()
|
|
}
|
|
},
|
|
);
|
|
reactions
|
|
})
|
|
.unwrap_or_default();
|
|
|
|
TextViewProps::default()
|
|
.content(body)
|
|
.footer(Some(reactions))
|
|
.cursor(state.preview.comment.cursor)
|
|
.show_scroll_progress(true)
|
|
.to_boxed_any()
|
|
.into()
|
|
}),
|
|
)
|
|
.to_widget(tx.clone())
|
|
}
|
|
|
|
fn help_page(channel: &Channel<Message>) -> Widget<State, Message> {
|
|
let tx = channel.tx.clone();
|
|
|
|
let content = Container::default()
|
|
.header(Header::default().to_widget(tx.clone()).on_update(|_| {
|
|
HeaderProps::default()
|
|
.columns([Column::new(" Help ", Constraint::Fill(1))].to_vec())
|
|
.to_boxed_any()
|
|
.into()
|
|
}))
|
|
.content(
|
|
TextView::default()
|
|
.to_widget(tx.clone())
|
|
.on_event(|_, view_state, _| {
|
|
view_state
|
|
.and_then(|tv| tv.unwrap_textview())
|
|
.map(|tvs| Message::ScrollHelp {
|
|
scroll: tvs.scroll,
|
|
cursor: tvs.cursor,
|
|
})
|
|
})
|
|
.on_update(|state: &State| {
|
|
TextViewProps::default()
|
|
.content(help_text())
|
|
.cursor(state.help.cursor)
|
|
.to_boxed_any()
|
|
.into()
|
|
}),
|
|
)
|
|
.footer(
|
|
Footer::default()
|
|
.to_widget(tx.clone())
|
|
.on_update(|state: &State| {
|
|
FooterProps::default()
|
|
.columns(
|
|
[
|
|
Column::new(Text::raw(""), Constraint::Fill(1)),
|
|
Column::new(
|
|
span::default(&format!("{}%", state.help.scroll)).dim(),
|
|
Constraint::Min(4),
|
|
),
|
|
]
|
|
.to_vec(),
|
|
)
|
|
.to_boxed_any()
|
|
.into()
|
|
}),
|
|
)
|
|
.to_widget(tx.clone());
|
|
|
|
let shortcuts = Shortcuts::default().to_widget(tx.clone()).on_update(|_| {
|
|
ShortcutsProps::default()
|
|
.shortcuts(&[("?", "close")])
|
|
.to_boxed_any()
|
|
.into()
|
|
});
|
|
|
|
Page::default()
|
|
.content(content)
|
|
.shortcuts(shortcuts)
|
|
.to_widget(tx.clone())
|
|
.on_event(|key, _, _| match key {
|
|
Key::Esc | Key::Ctrl('c') => Some(Message::Quit),
|
|
Key::Char('?') => Some(Message::LeavePage),
|
|
_ => None,
|
|
})
|
|
.on_update(|_| PageProps::default().handle_keys(true).to_boxed_any().into())
|
|
}
|
|
|
|
fn help_text() -> Text<'static> {
|
|
Text::from(
|
|
[
|
|
Line::from(Span::raw("Generic keybindings").cyan()),
|
|
Line::raw(""),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "↑,k")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("move cursor one line up").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "↓,j")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("move cursor one line down").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "PageUp")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("move cursor one page up").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "PageDown")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("move cursor one page down").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "Home")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("move cursor to the first line").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "End")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("move cursor to the last line").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::raw(""),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "Tab")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("focus next section").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "Backtab")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("focus previous section").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::raw(""),
|
|
Line::from(Span::raw("Specific keybindings").cyan()),
|
|
Line::raw(""),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "enter")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("Select issue (if --mode id)").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "enter")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("Show issue").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "e")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("Edit issue").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "p")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("Toggle issue preview").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "/")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("Search").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "?")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("Show help").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "Esc")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("Quit / cancel").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::raw(""),
|
|
Line::from(Span::raw("Searching").cyan()),
|
|
Line::raw(""),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "Pattern")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("is:<state> | is:authored | is:assigned | authors:[<did>, ...] | assignees:[<did>, ...] | <search>")
|
|
.gray()
|
|
.dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
Line::from(
|
|
[
|
|
Span::raw(format!("{key:>10}", key = "Example")).gray(),
|
|
Span::raw(": "),
|
|
Span::raw("is:solved is:authored alias").gray().dim(),
|
|
]
|
|
.to_vec(),
|
|
),
|
|
]
|
|
.to_vec())
|
|
}
|
|
|
|
fn append_opened(all: &mut HashSet<Vec<String>>, path: Vec<String>, comment: CommentItem) {
|
|
all.insert([path.clone(), [comment.id.to_string()].to_vec()].concat());
|
|
|
|
for reply in comment.replies {
|
|
append_opened(
|
|
all,
|
|
[path.clone(), [comment.id.to_string()].to_vec()].concat(),
|
|
reply,
|
|
);
|
|
}
|
|
}
|