369 lines
12 KiB
Rust
369 lines
12 KiB
Rust
use std::sync::Arc;
|
|
|
|
use gpui::{
|
|
AppContext, InteractiveElement, IntoElement, ParentElement, StatefulInteractiveElement, Styled,
|
|
div, img, prelude::FluentBuilder,
|
|
};
|
|
|
|
use crate::{
|
|
api::{self},
|
|
app,
|
|
component::{
|
|
button::{self, Button, button},
|
|
font_icon::{FontIcon, font_icon},
|
|
markdown::{self, MarkdownText},
|
|
text::text,
|
|
},
|
|
query::{self, QueryStatus, read_query, use_query},
|
|
screen::dashboard::pull_request_diff_view::{self, PullRequestDiffView},
|
|
};
|
|
|
|
pub(crate) struct PullRequestView {
|
|
markdown_viewer: Option<gpui::Entity<MarkdownText>>,
|
|
diff_view: Option<gpui::Entity<PullRequestDiffView>>,
|
|
|
|
pull_request_query: Option<query::Entity<api::issues::FetchPullRequest>>,
|
|
}
|
|
|
|
#[derive(gpui::IntoElement)]
|
|
struct Toolbar {}
|
|
|
|
pub fn new(_cx: &mut gpui::Context<PullRequestView>) -> PullRequestView {
|
|
PullRequestView {
|
|
markdown_viewer: None,
|
|
diff_view: None,
|
|
pull_request_query: None,
|
|
}
|
|
}
|
|
|
|
impl PullRequestView {
|
|
pub(crate) fn change_displayed_pull_request(
|
|
&mut self,
|
|
id: api::issues::Id,
|
|
cx: &mut gpui::Context<Self>,
|
|
) {
|
|
let query = use_query(api::issues::FetchPullRequest { id }, cx);
|
|
|
|
self.pull_request_query = Some(query.clone());
|
|
|
|
_ = cx
|
|
.observe(&query.clone(), move |this, _, cx| {
|
|
this.load_markdown_content(cx);
|
|
this.load_pr_diff(cx);
|
|
})
|
|
.detach();
|
|
|
|
// cached query will not trigger observe callback
|
|
// this is required so that content is loaded immediately for cached query
|
|
self.load_markdown_content(cx);
|
|
self.load_pr_diff(cx);
|
|
|
|
cx.notify();
|
|
}
|
|
|
|
fn load_markdown_content(&mut self, cx: &mut gpui::Context<Self>) {
|
|
let Some(query) = &self.pull_request_query else {
|
|
return;
|
|
};
|
|
|
|
let maybe_content = {
|
|
let data = read_query(&query, cx);
|
|
if let QueryStatus::Loaded(pr) = data {
|
|
Some(Arc::clone(&pr.body))
|
|
} else {
|
|
None
|
|
}
|
|
};
|
|
|
|
self.markdown_viewer = maybe_content.map(|content| cx.new(|cx| markdown::new(content, cx)));
|
|
|
|
cx.notify();
|
|
}
|
|
|
|
fn load_pr_diff(&mut self, cx: &mut gpui::Context<Self>) {
|
|
let Some(query) = &self.pull_request_query else {
|
|
return;
|
|
};
|
|
|
|
let pr_id = {
|
|
let data = read_query(&query, cx);
|
|
if let QueryStatus::Loaded(pr) = data {
|
|
Some(pr.id.clone())
|
|
} else {
|
|
None
|
|
}
|
|
};
|
|
|
|
self.diff_view = pr_id.map(|id| cx.new(|cx| pull_request_diff_view::new(id, cx)));
|
|
|
|
cx.notify();
|
|
}
|
|
|
|
fn pr_content(
|
|
&self,
|
|
pr: &api::issues::DetailedPullRequest,
|
|
cx: &gpui::Context<Self>,
|
|
) -> gpui::AnyElement {
|
|
let theme = app::current_theme(cx);
|
|
|
|
let mut status_pill = div()
|
|
.flex()
|
|
.flex_row()
|
|
.items_center()
|
|
.gap_1()
|
|
.px_2()
|
|
.rounded_full();
|
|
|
|
match pr.state {
|
|
| api::issues::PullRequestState::Open => {
|
|
status_pill = status_pill
|
|
.bg(theme.colors.success_solid)
|
|
.child(
|
|
font_icon(FontIcon::PullRequestArrow)
|
|
.size_3()
|
|
.text_color(theme.colors.success_on_solid),
|
|
)
|
|
.child(
|
|
text("Open")
|
|
.text_color(theme.colors.success_on_solid)
|
|
.text_xs(),
|
|
);
|
|
}
|
|
| api::issues::PullRequestState::Closed => {
|
|
status_pill = status_pill
|
|
.bg(theme.colors.danger_solid)
|
|
.child(
|
|
font_icon(FontIcon::PullRequestClosed)
|
|
.size_3()
|
|
.text_color(theme.colors.danger_on_solid),
|
|
)
|
|
.child(
|
|
text("Closed")
|
|
.text_color(theme.colors.danger_on_solid)
|
|
.text_xs(),
|
|
);
|
|
}
|
|
| api::issues::PullRequestState::Merged => {
|
|
status_pill = status_pill.bg(theme.colors.accent_solid).child(
|
|
text("Merged")
|
|
.text_color(theme.colors.accent_on_solid)
|
|
.text_xs(),
|
|
);
|
|
}
|
|
}
|
|
|
|
let merge_text = pr.author.as_ref().map(|author| {
|
|
let base_branch = &pr.base_branch_name;
|
|
let head_branch = &pr.head_branch_name;
|
|
let str = format!(
|
|
"{} requested to merge {} into {}",
|
|
author.login, head_branch, base_branch
|
|
);
|
|
|
|
let head_branch_text_offset = author.login.len() + 20;
|
|
let base_branch_text_offset = head_branch_text_offset + head_branch.len() + 6;
|
|
|
|
let highlights = [
|
|
(
|
|
0..author.login.len(),
|
|
gpui::HighlightStyle {
|
|
font_weight: Some(gpui::FontWeight::BOLD),
|
|
..Default::default()
|
|
},
|
|
),
|
|
(
|
|
head_branch_text_offset..head_branch_text_offset + head_branch.len(),
|
|
gpui::HighlightStyle {
|
|
font_weight: Some(gpui::FontWeight::BOLD),
|
|
color: Some(theme.colors.accent_fg.into()),
|
|
..Default::default()
|
|
},
|
|
),
|
|
(
|
|
base_branch_text_offset..base_branch_text_offset + base_branch.len(),
|
|
gpui::HighlightStyle {
|
|
font_weight: Some(gpui::FontWeight::BOLD),
|
|
color: Some(theme.colors.accent_fg.into()),
|
|
..Default::default()
|
|
},
|
|
),
|
|
];
|
|
|
|
(
|
|
author,
|
|
gpui::StyledText::new(str).with_highlights(highlights),
|
|
)
|
|
});
|
|
|
|
let pr_title = gpui::SharedString::new(Arc::clone(&pr.title));
|
|
|
|
let metadata_line =
|
|
div()
|
|
.flex()
|
|
.flex_row()
|
|
.gap_2()
|
|
.when_some(merge_text, |it, (author, t)| {
|
|
it.child(
|
|
div()
|
|
.flex()
|
|
.flex_row()
|
|
.items_center()
|
|
.gap_1p5()
|
|
.child(img(author.avatar_url.as_ref()).size_4().rounded_full())
|
|
.child(
|
|
div()
|
|
.min_w_0()
|
|
.w_full()
|
|
.text_color(theme.colors.text)
|
|
.text_xs()
|
|
.font_weight(gpui::FontWeight::LIGHT)
|
|
.opacity(0.8)
|
|
.child(t),
|
|
),
|
|
)
|
|
});
|
|
|
|
div()
|
|
.size_full()
|
|
.flex()
|
|
.flex_col()
|
|
.bg(theme.colors.surface)
|
|
.overflow_hidden()
|
|
.child(Toolbar {})
|
|
.child(
|
|
div()
|
|
.flex()
|
|
.flex_row()
|
|
.justify_between()
|
|
.items_center()
|
|
.w_full()
|
|
.px_3p5()
|
|
.py_3()
|
|
.border_b_1()
|
|
.border_color(theme.colors.border_muted)
|
|
.child(
|
|
div()
|
|
.w_full()
|
|
.flex()
|
|
.flex_col()
|
|
.items_start()
|
|
.child(text(pr_title).w_full().text_xl().mb_1())
|
|
.child(metadata_line),
|
|
)
|
|
.child(div().flex().flex_col().items_end().gap_1().when_some(
|
|
pr.created_at,
|
|
|it, created_at| {
|
|
it.child(
|
|
text(created_at.format("%Y-%m-%d %H:%M").to_string())
|
|
.opacity(0.5)
|
|
.text_xs(),
|
|
)
|
|
.child(status_pill)
|
|
},
|
|
)),
|
|
)
|
|
.child(
|
|
div().flex_1().min_h_0().w_full().child(
|
|
div()
|
|
.id("pr-body-content")
|
|
.size_full()
|
|
.overflow_y_scroll()
|
|
.when_some(self.markdown_viewer.as_ref(), |it, viewer| {
|
|
it.child(div().w_full().p_3p5().child(viewer.clone()))
|
|
}),
|
|
),
|
|
)
|
|
.into_any_element()
|
|
}
|
|
}
|
|
|
|
impl gpui::Render for PullRequestView {
|
|
fn render(
|
|
&mut self,
|
|
_window: &mut gpui::Window,
|
|
cx: &mut gpui::Context<Self>,
|
|
) -> impl gpui::IntoElement {
|
|
div().size_full().child(match &self.pull_request_query {
|
|
| Some(q) => match read_query(q, cx) {
|
|
| QueryStatus::Loaded(pr) => match &self.diff_view {
|
|
| Some(v) => v.clone().into_any_element(),
|
|
| None => self.pr_content(pr, cx),
|
|
},
|
|
|
|
| QueryStatus::Err(e) => div()
|
|
.size_full()
|
|
.child(format!("{:?}", e))
|
|
.into_any_element(),
|
|
| QueryStatus::Loading => div()
|
|
.size_full()
|
|
.child("loading pr content")
|
|
.into_any_element(),
|
|
},
|
|
|
|
| None => div().size_full().child("no pr selected").into_any_element(),
|
|
})
|
|
}
|
|
}
|
|
|
|
impl gpui::RenderOnce for Toolbar {
|
|
fn render(self, _window: &mut gpui::Window, cx: &mut gpui::App) -> impl IntoElement {
|
|
fn toolbar_button(id: impl Into<gpui::ElementId>) -> Button {
|
|
button(id)
|
|
.px_2p5()
|
|
.py_1()
|
|
.variant(button::Variant::Secondary)
|
|
.border_0()
|
|
}
|
|
|
|
fn divider() -> gpui::Div {
|
|
div().h_full().w_px()
|
|
}
|
|
|
|
let theme = app::current_theme(cx);
|
|
|
|
div()
|
|
.w_full()
|
|
.flex()
|
|
.flex_row()
|
|
.items_center()
|
|
.justify_start()
|
|
.p_1()
|
|
.bg(theme.colors.surface)
|
|
.border_b_1()
|
|
.border_color(theme.colors.border_muted)
|
|
.child(
|
|
toolbar_button("pr-review-btn")
|
|
.leading(font_icon(FontIcon::Eye))
|
|
.mr_1(),
|
|
)
|
|
.child(
|
|
toolbar_button("pr-review-btn")
|
|
.leading(font_icon(FontIcon::RefreshCw))
|
|
.mr_1(),
|
|
)
|
|
.child(divider().bg(theme.colors.border).mr_1())
|
|
.child(toolbar_button("pr-review-btn").leading(font_icon(FontIcon::Star)))
|
|
.child(div().flex_1())
|
|
.child(
|
|
toolbar_button("pr-close-btn")
|
|
.leading(font_icon(FontIcon::PullRequestClosed))
|
|
.mr_1(),
|
|
)
|
|
.child(
|
|
toolbar_button("pr-merge-btn")
|
|
.variant(button::Variant::Primary)
|
|
.leading(font_icon(FontIcon::GitMerge))
|
|
.rounded_r_none(),
|
|
)
|
|
.child(divider())
|
|
.child(
|
|
toolbar_button("chevron")
|
|
.py_1()
|
|
.px_0p5()
|
|
.variant(button::Variant::Primary)
|
|
.leading(font_icon(FontIcon::ChevronDown))
|
|
.rounded_l_none(),
|
|
)
|
|
}
|
|
}
|