433 lines
16 KiB
Rust
433 lines
16 KiB
Rust
//! Issues panel: a bottom panel listing every issue of the repository with
|
|
//! its title, event id, author, age and status, filterable by status via
|
|
//! the header's All/Open/Closed filter.
|
|
|
|
use std::rc::Rc;
|
|
|
|
use assets::CustomIconName;
|
|
use gpui::prelude::*;
|
|
use gpui::{
|
|
AnyElement, App, Context, Entity, EventEmitter, FocusHandle, Focusable, Pixels, Render,
|
|
SharedString, Size, Window, div, px, size,
|
|
};
|
|
use gpui_component::avatar::Avatar;
|
|
use gpui_component::button::{Button, ButtonVariants};
|
|
use gpui_component::dialog::{DialogDescription, DialogFooter, DialogHeader, DialogTitle};
|
|
use gpui_component::dock::{Panel, PanelEvent};
|
|
use gpui_component::form::{field, v_form};
|
|
use gpui_component::input::{Input, InputState, Textarea, TextareaState};
|
|
use gpui_component::scroll::Scrollbar;
|
|
use gpui_component::tooltip::Tooltip;
|
|
use gpui_component::{
|
|
ActiveTheme, Icon, IconName, Selectable, Sizable, StyledExt, VirtualListScrollHandle,
|
|
WindowExt, h_flex, v_flex, v_virtual_list,
|
|
};
|
|
use nostr::prelude::Event;
|
|
use signed_core::{RepoStatus, activity_subject};
|
|
use signed_state::{ProfileStore, RepoStore};
|
|
use utils::relative_time;
|
|
|
|
use super::helpers::placeholder;
|
|
|
|
/// Height of one issue row in the virtual list: 12px padding on top and
|
|
/// bottom, a 14px title line and a 24px meta line (the small avatar is the
|
|
/// tallest item). Gpui's default line height is phi (~1.62x), so the title
|
|
/// line is ~22.7px; the row totals ~71px.
|
|
const ISSUE_ROW_HEIGHT: f32 = 71.;
|
|
|
|
/// Status filter of the issues list, chosen via the header's filter buttons.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum IssueFilter {
|
|
/// Every issue, regardless of status.
|
|
All,
|
|
/// Issues whose resolved status is [`RepoStatus::Open`].
|
|
Open,
|
|
/// Issues whose resolved status is [`RepoStatus::Closed`].
|
|
Closed,
|
|
}
|
|
|
|
impl IssueFilter {
|
|
/// Whether `issue` (of `store`) is included by this filter.
|
|
fn matches(self, store: &RepoStore, issue: &Event) -> bool {
|
|
match self {
|
|
Self::All => true,
|
|
Self::Open => store.status_of(issue) == RepoStatus::Open,
|
|
Self::Closed => store.status_of(issue) == RepoStatus::Closed,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct IssuesView {
|
|
focus_handle: FocusHandle,
|
|
/// Repo store holding the issues and their statuses.
|
|
store: Entity<RepoStore>,
|
|
/// Display name of the repository, for the panel title.
|
|
repo_name: SharedString,
|
|
/// Filter selected in the header filter buttons.
|
|
filter: IssueFilter,
|
|
/// Per-row heights of the virtual list.
|
|
item_sizes: Rc<Vec<Size<Pixels>>>,
|
|
/// Number of rows [`Self::item_sizes`] was built for (the filtered
|
|
/// issue count); rebuilt on change.
|
|
issue_len: usize,
|
|
/// Indices into the store's `issues` matching [`Self::filter`], rebuilt
|
|
/// every render; the virtual list renders this slice.
|
|
visible_issues: Vec<usize>,
|
|
/// Virtual list state of the issues list.
|
|
scroll_handle: VirtualListScrollHandle,
|
|
}
|
|
|
|
impl IssuesView {
|
|
pub fn new(
|
|
store: Entity<RepoStore>,
|
|
repo_name: SharedString,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Self {
|
|
// Issue author avatars stay in the shared cache until the panel
|
|
// closes; free them then.
|
|
crate::image_cache::clear_on_release(&cx.entity(), window, cx);
|
|
|
|
Self {
|
|
focus_handle: cx.focus_handle(),
|
|
store,
|
|
repo_name,
|
|
filter: IssueFilter::Open,
|
|
item_sizes: Rc::new(Vec::new()),
|
|
issue_len: 0,
|
|
visible_issues: Vec::new(),
|
|
scroll_handle: VirtualListScrollHandle::new(),
|
|
}
|
|
}
|
|
|
|
fn render_row(&self, ix: usize, issue: &Event, cx: &App) -> AnyElement {
|
|
let title = activity_subject(issue);
|
|
let id_hex = issue.id.to_hex();
|
|
let profile = ProfileStore::global(cx).read(cx).get(&issue.pubkey);
|
|
let author = profile.name();
|
|
let picture = profile.picture();
|
|
let age = relative_time(issue.created_at);
|
|
let status = self.store.read(cx).status_of(issue);
|
|
|
|
h_flex()
|
|
.id(ix)
|
|
.h(px(ISSUE_ROW_HEIGHT))
|
|
.w_full()
|
|
.gap_4()
|
|
.p_3()
|
|
.border_b_1()
|
|
.border_color(cx.theme().border)
|
|
.items_start()
|
|
.child(Self::render_status(status, cx))
|
|
.child(
|
|
v_flex()
|
|
.flex_1()
|
|
.child(
|
|
div()
|
|
.min_w_0()
|
|
.text_ellipsis()
|
|
.whitespace_nowrap()
|
|
.line_clamp(1)
|
|
.text_sm()
|
|
.child(title),
|
|
)
|
|
.child(
|
|
h_flex()
|
|
.gap_2()
|
|
.text_xs()
|
|
.child(
|
|
h_flex()
|
|
.gap_1()
|
|
.child(
|
|
Avatar::new()
|
|
.name(author.clone())
|
|
.when_some(picture, |this, url| this.src(url))
|
|
.xsmall(),
|
|
)
|
|
.child(div().child(author)),
|
|
)
|
|
.child(SharedString::from("opened"))
|
|
.child(
|
|
div()
|
|
.text_color(cx.theme().muted_foreground)
|
|
.child(SharedString::from(&id_hex[..8])),
|
|
)
|
|
.child(div().child(age)),
|
|
),
|
|
)
|
|
.into_any_element()
|
|
}
|
|
|
|
fn render_status(status: RepoStatus, cx: &App) -> AnyElement {
|
|
let (icon, label, tooltip, bg, fg) = match status {
|
|
RepoStatus::Open => (
|
|
CustomIconName::GitIssueOpen,
|
|
"open",
|
|
"Issue is open",
|
|
cx.theme().secondary,
|
|
cx.theme().secondary_foreground,
|
|
),
|
|
RepoStatus::Closed => (
|
|
CustomIconName::GitIssueClosed,
|
|
"closed",
|
|
"Issue is closed",
|
|
cx.theme().warning,
|
|
cx.theme().warning_foreground,
|
|
),
|
|
RepoStatus::Draft => (
|
|
CustomIconName::GitIssueOngoing,
|
|
"draft",
|
|
"Issue is draft",
|
|
cx.theme().accent,
|
|
cx.theme().accent_foreground,
|
|
),
|
|
RepoStatus::Applied => (
|
|
CustomIconName::GitIssueOpen,
|
|
"applied",
|
|
"Issue is completed",
|
|
cx.theme().primary,
|
|
cx.theme().primary_foreground,
|
|
),
|
|
};
|
|
|
|
v_flex()
|
|
.id(label)
|
|
.flex_shrink_0()
|
|
.size_6()
|
|
.items_center()
|
|
.justify_center()
|
|
.rounded(cx.theme().radius)
|
|
.bg(bg)
|
|
.child(Icon::new(icon).xsmall().text_color(fg))
|
|
.tooltip(move |window, cx| Tooltip::new(tooltip).build(window, cx))
|
|
.into_any_element()
|
|
}
|
|
|
|
fn render_header(&self, cx: &mut Context<Self>) -> AnyElement {
|
|
h_flex()
|
|
.w_full()
|
|
.items_center()
|
|
.gap_3()
|
|
.px_3()
|
|
.pb_2()
|
|
.border_b_1()
|
|
.border_color(cx.theme().border)
|
|
.child(
|
|
div()
|
|
.text_sm()
|
|
.text_color(cx.theme().muted_foreground)
|
|
.font_semibold()
|
|
.child("Issues"),
|
|
)
|
|
.child(
|
|
h_flex()
|
|
.gap_1()
|
|
.child(
|
|
Button::new("all")
|
|
.icon(CustomIconName::GitIssueOpen)
|
|
.label("All")
|
|
.ghost()
|
|
.selected(self.filter == IssueFilter::All)
|
|
.on_click(cx.listener(|this, _event, _window, cx| {
|
|
this.filter = IssueFilter::All;
|
|
cx.notify();
|
|
})),
|
|
)
|
|
.child(
|
|
Button::new("open")
|
|
.icon(CustomIconName::GitIssueOpen)
|
|
.label("Open")
|
|
.ghost()
|
|
.selected(self.filter == IssueFilter::Open)
|
|
.on_click(cx.listener(|this, _event, _window, cx| {
|
|
this.filter = IssueFilter::Open;
|
|
cx.notify();
|
|
})),
|
|
)
|
|
.child(
|
|
Button::new("closed")
|
|
.icon(CustomIconName::GitIssueClosed)
|
|
.label("Closed")
|
|
.ghost()
|
|
.selected(self.filter == IssueFilter::Closed)
|
|
.on_click(cx.listener(|this, _event, _window, cx| {
|
|
this.filter = IssueFilter::Closed;
|
|
cx.notify();
|
|
})),
|
|
),
|
|
)
|
|
// Spacer: pushes the button to the right edge.
|
|
.child(div().flex_1())
|
|
.child(
|
|
Button::new("new-issue")
|
|
.icon(IconName::Plus)
|
|
.label("New issue")
|
|
.primary()
|
|
.on_click(cx.listener(|this, _event, window, cx| {
|
|
open_new_issue_dialog(this.store.clone(), window, cx);
|
|
})),
|
|
)
|
|
.into_any_element()
|
|
}
|
|
}
|
|
|
|
/// Open the "new issue" dialog: a title and a content input that submit
|
|
/// through [`RepoStore::open_issue`] when confirmed.
|
|
fn open_new_issue_dialog(store: Entity<RepoStore>, window: &mut Window, cx: &mut App) {
|
|
let subject = cx.new(|cx| InputState::new(window, cx).placeholder("Issue title"));
|
|
let content = cx.new(|cx| TextareaState::new(window, cx).placeholder("Describe the issue…"));
|
|
|
|
window.open_dialog(cx, move |dialog, _window, _cx| {
|
|
let subject = subject.clone();
|
|
let content = content.clone();
|
|
let store = store.clone();
|
|
|
|
dialog
|
|
.width(px(520.))
|
|
.margin_top(px(50.))
|
|
.content(move |body, _window, _cx| {
|
|
body.child(
|
|
DialogHeader::new()
|
|
.child(DialogTitle::new().child("New issue"))
|
|
.child(
|
|
DialogDescription::new()
|
|
.child("Report a bug, ask a question, or propose a change."),
|
|
),
|
|
)
|
|
.child(
|
|
v_form()
|
|
.child(
|
|
field()
|
|
.label("Title")
|
|
.required(true)
|
|
.child(Input::new(&subject)),
|
|
)
|
|
.child(
|
|
field()
|
|
.label("Content")
|
|
.child(Textarea::new(&content).h(px(160.))),
|
|
),
|
|
)
|
|
.child(
|
|
DialogFooter::new().justify_end().child(
|
|
Button::new("submit")
|
|
.primary()
|
|
.label("Create issue")
|
|
.tooltip("Create issue")
|
|
.on_click({
|
|
let subject = subject.clone();
|
|
let content = content.clone();
|
|
let store = store.clone();
|
|
|
|
move |_event, window, cx| {
|
|
let subject = subject.read(cx).value().to_string();
|
|
let content = content.read(cx).value().to_string();
|
|
let subject = (!subject.is_empty()).then_some(subject);
|
|
|
|
store.update(cx, |store, cx| {
|
|
store.open_issue(subject, content, cx);
|
|
});
|
|
|
|
window.close_dialog(cx);
|
|
}
|
|
}),
|
|
),
|
|
)
|
|
})
|
|
});
|
|
}
|
|
|
|
impl Panel for IssuesView {
|
|
fn panel_name(&self) -> &'static str {
|
|
"issues"
|
|
}
|
|
|
|
fn title(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
|
|
div().child(SharedString::from(format!("{}/issues", self.repo_name)))
|
|
}
|
|
}
|
|
|
|
impl EventEmitter<PanelEvent> for IssuesView {}
|
|
|
|
impl Focusable for IssuesView {
|
|
fn focus_handle(&self, _cx: &App) -> FocusHandle {
|
|
self.focus_handle.clone()
|
|
}
|
|
}
|
|
|
|
impl Render for IssuesView {
|
|
fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
|
|
let filter = self.filter;
|
|
|
|
// Indices of the issues matching the active filter; the virtual
|
|
// list renders this filtered slice.
|
|
self.visible_issues = {
|
|
let store = self.store.read(cx);
|
|
store
|
|
.issues
|
|
.iter()
|
|
.enumerate()
|
|
.filter(|(_, issue)| filter.matches(store, issue))
|
|
.map(|(ix, _)| ix)
|
|
.collect()
|
|
};
|
|
|
|
let count = self.visible_issues.len();
|
|
|
|
// The virtual list's item count comes from `item_sizes`; rebuild it
|
|
// whenever the filtered issue count changes.
|
|
if count != self.issue_len {
|
|
self.issue_len = count;
|
|
self.item_sizes = Rc::new(vec![size(px(0.), px(ISSUE_ROW_HEIGHT)); count]);
|
|
}
|
|
|
|
let sizes = self.item_sizes.clone();
|
|
let scroll_handle = self.scroll_handle.clone();
|
|
let view = cx.entity().clone();
|
|
|
|
v_flex()
|
|
.size_full()
|
|
.child(self.render_header(cx))
|
|
.child(
|
|
v_flex()
|
|
.relative()
|
|
.flex_1()
|
|
.min_h_0()
|
|
.w_full()
|
|
.when(count > 0, |this| {
|
|
this.child(
|
|
v_virtual_list(view, "il", sizes, move |this, range, _window, cx| {
|
|
let issues = &this.store.read(cx).issues;
|
|
range
|
|
.map(|ix| {
|
|
let issue_ix = this.visible_issues[ix];
|
|
this.render_row(issue_ix, &issues[issue_ix], cx)
|
|
})
|
|
.collect()
|
|
})
|
|
.track_scroll(&scroll_handle)
|
|
.size_full(),
|
|
)
|
|
.child(
|
|
div()
|
|
.absolute()
|
|
.top_0()
|
|
.left_0()
|
|
.right_0()
|
|
.bottom_0()
|
|
.child(Scrollbar::vertical(&scroll_handle)),
|
|
)
|
|
})
|
|
.when(count == 0, |this| {
|
|
let message = match filter {
|
|
IssueFilter::All => "No issues",
|
|
IssueFilter::Open => "No open issues",
|
|
IssueFilter::Closed => "No closed issues",
|
|
};
|
|
this.child(placeholder(message, cx))
|
|
}),
|
|
)
|
|
.into_any_element()
|
|
}
|
|
}
|