455 lines
18 KiB
Rust
455 lines
18 KiB
Rust
use std::rc::Rc;
|
|
|
|
use assets::CustomIconName;
|
|
use dock::{BasePanel, DockArea, Panel, PanelEvent, add_center_panel, panel_handle};
|
|
use gpui::prelude::*;
|
|
use gpui::{
|
|
AnyElement, App, Context, Entity, EventEmitter, FocusHandle, Focusable, Pixels, Render,
|
|
SharedString, Size, WeakEntity, Window, div, px, size,
|
|
};
|
|
use gpui_base::Button as BaseButton;
|
|
use gpui_component::alert::Alert;
|
|
use gpui_component::scroll::Scrollbar;
|
|
use gpui_component::{
|
|
ActiveTheme, Icon, IconName, VirtualListScrollHandle, h_flex, v_flex, v_virtual_list,
|
|
};
|
|
use nostr::prelude::{EventId, Kind};
|
|
use signed_core::{RepoStatus, activity_subject};
|
|
use signed_state::{ProfileStore, RepoStore};
|
|
use signed_ui::{DropdownButton, SegmentButton, UserAvatar, placeholder, status_badge};
|
|
use utils::relative_time;
|
|
|
|
use super::RepoAction;
|
|
use super::new_pull_request::open_new_pull_panel;
|
|
use super::pull_request_detail::PullRequestDetailView;
|
|
use super::send_patch::open_send_patch_panel;
|
|
|
|
/// Height of one pull request row in the virtual list.
|
|
const ROW_HEIGHT: f32 = 73.;
|
|
|
|
/// Status filter of the pull request list, chosen via the header's filter buttons.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum PullRequestFilter {
|
|
/// Every pull request, regardless of status.
|
|
All,
|
|
/// Pull requests whose resolved status is [`RepoStatus::Open`].
|
|
Open,
|
|
/// Pull requests whose resolved status is [`RepoStatus::Closed`].
|
|
Closed,
|
|
/// Pull requests whose resolved status is [`RepoStatus::Draft`].
|
|
Draft,
|
|
/// Pull requests whose resolved status is [`RepoStatus::Applied`].
|
|
Merged,
|
|
}
|
|
|
|
impl PullRequestFilter {
|
|
/// Whether a pull request with `status` is included by this filter.
|
|
fn matches(self, status: RepoStatus) -> bool {
|
|
match self {
|
|
Self::All => true,
|
|
Self::Open => status == RepoStatus::Open,
|
|
Self::Closed => status == RepoStatus::Closed,
|
|
Self::Draft => status == RepoStatus::Draft,
|
|
Self::Merged => status == RepoStatus::Applied,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct PullRequestsView {
|
|
focus_handle: FocusHandle,
|
|
/// Dock area the detail panels are added to.
|
|
dock_area: WeakEntity<DockArea>,
|
|
/// Repo store holding the pull requests 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: PullRequestFilter,
|
|
/// Per-row heights of the virtual list.
|
|
item_sizes: Rc<Vec<Size<Pixels>>>,
|
|
/// The filtered pull request count [`Self::item_sizes`] was built for.
|
|
pr_len: usize,
|
|
/// Indices into the store's `pull_requests` matching [`Self::filter`].
|
|
visible_prs: Vec<usize>,
|
|
/// Header counts `(total, open, closed, draft, merged)`.
|
|
counts: (usize, usize, usize, usize, usize),
|
|
/// Store version and filter the cached rows/counts were built from.
|
|
cache_key: Option<(u64, PullRequestFilter)>,
|
|
/// Virtual list state of the pull requests list.
|
|
scroll_handle: VirtualListScrollHandle,
|
|
}
|
|
|
|
impl PullRequestsView {
|
|
pub fn new(
|
|
dock_area: WeakEntity<DockArea>,
|
|
store: Entity<RepoStore>,
|
|
_window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) -> Self {
|
|
let repo_name = store.read(cx).name();
|
|
|
|
Self {
|
|
focus_handle: cx.focus_handle(),
|
|
dock_area,
|
|
store,
|
|
repo_name,
|
|
filter: PullRequestFilter::Open,
|
|
item_sizes: Rc::new(Vec::new()),
|
|
pr_len: 0,
|
|
visible_prs: Vec::new(),
|
|
counts: (0, 0, 0, 0, 0),
|
|
cache_key: None,
|
|
scroll_handle: VirtualListScrollHandle::new(),
|
|
}
|
|
}
|
|
|
|
/// Open the detail panel of `pr_id` in the dock area.
|
|
fn open_pull_request_detail(
|
|
&mut self,
|
|
pr_id: EventId,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
let Some(dock_area) = self.dock_area.upgrade() else {
|
|
return;
|
|
};
|
|
|
|
let panel = cx.new(|cx| {
|
|
PullRequestDetailView::new(
|
|
self.dock_area.clone(),
|
|
self.store.clone(),
|
|
pr_id,
|
|
window,
|
|
cx,
|
|
)
|
|
});
|
|
|
|
dock_area.update(cx, |dock_area, cx| {
|
|
add_center_panel(dock_area, panel_handle(panel), window, cx);
|
|
});
|
|
}
|
|
|
|
/// Render one row of the pull request list.
|
|
///
|
|
/// `ix` is the row index, `pr_ix` the index in the store's `pull_requests`.
|
|
fn render_row(&self, ix: usize, pr_ix: usize, cx: &mut Context<Self>) -> AnyElement {
|
|
let pr = &self.store.read(cx).pull_requests[pr_ix];
|
|
let pr_id = pr.id;
|
|
let title = activity_subject(pr);
|
|
let id_hex = pr.id.to_hex();
|
|
|
|
let age = relative_time(pr.created_at);
|
|
let status = self.store.read(cx).status_of(pr);
|
|
|
|
let profile = ProfileStore::global(cx).read(cx).get(&pr.pubkey);
|
|
let author = profile.name();
|
|
let picture = profile.picture();
|
|
|
|
h_flex()
|
|
.id(ix)
|
|
.w_full()
|
|
.gap_4()
|
|
.px_4()
|
|
.py_2()
|
|
.border_b_1()
|
|
.border_color(cx.theme().border)
|
|
.items_start()
|
|
.on_click(cx.listener(move |this, _event, window, cx| {
|
|
this.open_pull_request_detail(pr_id, window, cx);
|
|
}))
|
|
.child(status_badge(status, cx))
|
|
.child(
|
|
v_flex()
|
|
.flex_1()
|
|
.child(
|
|
div()
|
|
.h_8()
|
|
.min_w_0()
|
|
.text_ellipsis()
|
|
.whitespace_nowrap()
|
|
.line_clamp(1)
|
|
.text_sm()
|
|
.child(title),
|
|
)
|
|
.child(
|
|
h_flex()
|
|
.h_6()
|
|
.gap_2()
|
|
.text_xs()
|
|
.child(
|
|
h_flex()
|
|
.gap_1()
|
|
.child(UserAvatar::new(author.clone()).picture(picture))
|
|
.child(div().child(author)),
|
|
)
|
|
.child(SharedString::from("opened"))
|
|
.child(
|
|
div()
|
|
.text_color(cx.theme().muted_foreground)
|
|
.child(SharedString::from(&id_hex[..8])),
|
|
)
|
|
.child(SharedString::from(age)),
|
|
),
|
|
)
|
|
.hover(|this| this.bg(cx.theme().list_hover))
|
|
.into_any_element()
|
|
}
|
|
|
|
fn render_header(&self, cx: &mut Context<Self>) -> AnyElement {
|
|
// Counts of the last list rebuild.
|
|
let (total, open, closed, draft, merged) = self.counts;
|
|
|
|
h_flex()
|
|
.px_4()
|
|
.w_full()
|
|
.gap_3()
|
|
.border_b_1()
|
|
.border_color(cx.theme().border)
|
|
.bg(cx.theme().muted.opacity(0.5))
|
|
.child(
|
|
h_flex()
|
|
.h_12()
|
|
.gap_1()
|
|
.child(
|
|
SegmentButton::new("all", "All")
|
|
.icon(Icon::new(CustomIconName::GitPullRequest))
|
|
.count(total)
|
|
.selected(self.filter == PullRequestFilter::All)
|
|
.on_click(cx.listener(|this, _event, _window, cx| {
|
|
this.filter = PullRequestFilter::All;
|
|
cx.notify();
|
|
})),
|
|
)
|
|
.child(
|
|
SegmentButton::new("open", "Open")
|
|
.icon(Icon::new(CustomIconName::GitPullRequest))
|
|
.count(open)
|
|
.selected(self.filter == PullRequestFilter::Open)
|
|
.on_click(cx.listener(|this, _event, _window, cx| {
|
|
this.filter = PullRequestFilter::Open;
|
|
cx.notify();
|
|
})),
|
|
)
|
|
.child(
|
|
SegmentButton::new("closed", "Closed")
|
|
.icon(Icon::new(CustomIconName::GitPullRequestClosed))
|
|
.count(closed)
|
|
.selected(self.filter == PullRequestFilter::Closed)
|
|
.on_click(cx.listener(|this, _event, _window, cx| {
|
|
this.filter = PullRequestFilter::Closed;
|
|
cx.notify();
|
|
})),
|
|
)
|
|
.child(
|
|
SegmentButton::new("draft", "Draft")
|
|
.icon(Icon::new(CustomIconName::GitPullRequestDraft))
|
|
.count(draft)
|
|
.selected(self.filter == PullRequestFilter::Draft)
|
|
.on_click(cx.listener(|this, _event, _window, cx| {
|
|
this.filter = PullRequestFilter::Draft;
|
|
cx.notify();
|
|
})),
|
|
)
|
|
.child(
|
|
SegmentButton::new("merged", "Merged")
|
|
.icon(Icon::new(CustomIconName::GitPullRequestMerged))
|
|
.count(merged)
|
|
.selected(self.filter == PullRequestFilter::Merged)
|
|
.on_click(cx.listener(|this, _event, _window, cx| {
|
|
this.filter = PullRequestFilter::Merged;
|
|
cx.notify();
|
|
})),
|
|
),
|
|
)
|
|
.child(div().flex_1())
|
|
.child(
|
|
h_flex().items_center().child(
|
|
DropdownButton::new("new-pr-actions")
|
|
.action(
|
|
BaseButton::new("new-pr")
|
|
.child(
|
|
h_flex()
|
|
.h_8()
|
|
.px_2()
|
|
.gap_1()
|
|
.rounded(cx.theme().radius)
|
|
.bg(cx.theme().primary)
|
|
.hover(|this| this.bg(cx.theme().primary_hover))
|
|
.text_sm()
|
|
.text_color(cx.theme().primary_foreground)
|
|
.child(Icon::new(IconName::Plus))
|
|
.child("New"),
|
|
)
|
|
.on_click(cx.listener(|this, _event, window, cx| {
|
|
open_new_pull_panel(
|
|
this.dock_area.clone(),
|
|
this.store.clone(),
|
|
window,
|
|
cx,
|
|
);
|
|
})),
|
|
)
|
|
.dropdown_menu(|menu, _, _| {
|
|
menu.menu_element(Box::new(RepoAction::SendPatch), |_, _| {
|
|
h_flex()
|
|
.gap_2()
|
|
.text_sm()
|
|
.child(Icon::new(IconName::File))
|
|
.child("Send Patch")
|
|
})
|
|
}),
|
|
),
|
|
)
|
|
.into_any_element()
|
|
}
|
|
}
|
|
|
|
impl BasePanel for PullRequestsView {
|
|
fn panel_name(&self) -> &'static str {
|
|
"pull-requests"
|
|
}
|
|
}
|
|
|
|
impl Panel for PullRequestsView {
|
|
fn title(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
|
|
div().child(SharedString::from(format!(
|
|
"{}/pull-requests",
|
|
self.repo_name
|
|
)))
|
|
}
|
|
}
|
|
|
|
impl EventEmitter<PanelEvent> for PullRequestsView {}
|
|
|
|
impl Focusable for PullRequestsView {
|
|
fn focus_handle(&self, _cx: &App) -> FocusHandle {
|
|
self.focus_handle.clone()
|
|
}
|
|
}
|
|
|
|
impl Render for PullRequestsView {
|
|
fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
|
|
let filter = self.filter;
|
|
|
|
// Rows and counts are rebuilt only when the store refreshed or filter changed.
|
|
let version = self.store.read(cx).version();
|
|
|
|
if self.cache_key != Some((version, filter)) {
|
|
let store = self.store.read(cx);
|
|
let mut counts = (0usize, 0usize, 0usize, 0usize, 0usize);
|
|
self.visible_prs = store
|
|
.pull_requests
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(ix, pr)| {
|
|
if pr.kind != Kind::GitPullRequest {
|
|
return None;
|
|
}
|
|
|
|
let status = store.status_of(pr);
|
|
counts.0 += 1;
|
|
|
|
match status {
|
|
RepoStatus::Open => counts.1 += 1,
|
|
RepoStatus::Closed => counts.2 += 1,
|
|
RepoStatus::Draft => counts.3 += 1,
|
|
RepoStatus::Applied => counts.4 += 1,
|
|
}
|
|
|
|
filter.matches(status).then_some(ix)
|
|
})
|
|
.collect();
|
|
|
|
self.counts = counts;
|
|
self.cache_key = Some((version, filter));
|
|
}
|
|
|
|
let count = self.visible_prs.len();
|
|
|
|
// The virtual list's item count comes from `item_sizes`.
|
|
// Rebuild it whenever the filtered pull request count changes.
|
|
if count != self.pr_len {
|
|
self.pr_len = count;
|
|
self.item_sizes = Rc::new(vec![size(px(0.), px(ROW_HEIGHT)); count]);
|
|
}
|
|
|
|
let sizes = self.item_sizes.clone();
|
|
let scroll_handle = self.scroll_handle.clone();
|
|
let view = cx.entity().clone();
|
|
|
|
// Non-fatal warnings and errors of the last action, like creating or updating a PR.
|
|
// Shown as dismissible banners above the list.
|
|
let (last_error, last_warning) = {
|
|
let store = self.store.read(cx);
|
|
(store.last_error.clone(), store.last_warning.clone())
|
|
};
|
|
|
|
v_flex()
|
|
.size_full()
|
|
.image_cache(gpui::retain_all("pull-requests"))
|
|
.on_action(cx.listener(|this, action: &RepoAction, window, cx| {
|
|
if action == &RepoAction::SendPatch {
|
|
open_send_patch_panel(this.dock_area.clone(), this.store.clone(), window, cx);
|
|
}
|
|
}))
|
|
.child(self.render_header(cx))
|
|
.when_some(last_warning, |this, warning| {
|
|
this.child(Alert::warning("pr-warning", warning).banner().on_close({
|
|
let store = self.store.clone();
|
|
move |_event, _window, cx| {
|
|
store.update(cx, |store, _| store.last_warning = None);
|
|
}
|
|
}))
|
|
})
|
|
.when_some(last_error, |this, error| {
|
|
this.child(Alert::error("pr-error", error).banner().on_close({
|
|
let store = self.store.clone();
|
|
move |_event, _window, cx| {
|
|
store.update(cx, |store, _| store.last_error = None);
|
|
}
|
|
}))
|
|
})
|
|
.child(
|
|
v_flex()
|
|
.relative()
|
|
.flex_1()
|
|
.min_h_0()
|
|
.w_full()
|
|
.when(count > 0, |this| {
|
|
this.child(
|
|
v_virtual_list(view, "prl", sizes, move |this, range, _window, cx| {
|
|
range
|
|
.map(|ix| {
|
|
let pr_ix = this.visible_prs[ix];
|
|
this.render_row(ix, pr_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 {
|
|
PullRequestFilter::All => "No pull requests",
|
|
PullRequestFilter::Open => "No open pull requests",
|
|
PullRequestFilter::Closed => "No closed pull requests",
|
|
PullRequestFilter::Draft => "No draft pull requests",
|
|
PullRequestFilter::Merged => "No merged pull requests",
|
|
};
|
|
this.child(placeholder(message, cx))
|
|
}),
|
|
)
|
|
.into_any_element()
|
|
}
|
|
}
|