437 lines
16 KiB
Rust
437 lines
16 KiB
Rust
use std::collections::{HashMap, HashSet};
|
|
use std::path::{Component, Path, PathBuf};
|
|
|
|
use anyhow::Error;
|
|
use assets::CustomIconName;
|
|
use gpui::prelude::*;
|
|
use gpui::{
|
|
App, ClipboardItem, Context, Entity, EventEmitter, FocusHandle, Focusable, Render,
|
|
SharedString, Task, Window, div,
|
|
};
|
|
use gpui_component::button::{Button, ButtonVariants, DropdownButton};
|
|
use gpui_component::dock::{Panel, PanelEvent};
|
|
use gpui_component::menu::PopupMenuItem;
|
|
use gpui_component::tree::TreeState;
|
|
use gpui_component::{ActiveTheme, IconName, StyledExt, h_flex, v_flex};
|
|
use signed_core::Announcement;
|
|
use signed_git::FileCommit;
|
|
use signed_state::{GitStore, RepoStore};
|
|
|
|
mod browser;
|
|
mod helpers;
|
|
|
|
use browser::{CodeView, FileContent, MAX_PREVIEW_BYTES, MarkdownView};
|
|
use helpers::{build_tree_items, is_markdown_path};
|
|
|
|
/// Detail view of a repository: header, stats, a file explorer with README
|
|
/// preview (cloned from the announcement's `clone` URLs), and metadata.
|
|
pub struct RepoDetailView {
|
|
/// Live per-repository store, refreshed from the local database.
|
|
store: Entity<RepoStore>,
|
|
/// Snapshot taken at open time, shown until the store's first refresh completes.
|
|
initial: Announcement,
|
|
/// File explorer state (worktree of the local clone).
|
|
tree_state: Entity<TreeState>,
|
|
/// Root of the local clone, for reading files on demand.
|
|
worktree: Option<PathBuf>,
|
|
/// Markdown document currently in the preview pane (README or a file).
|
|
md: Option<MarkdownView>,
|
|
/// Code file currently in the preview pane.
|
|
code: Option<CodeView>,
|
|
readme_name: Option<SharedString>,
|
|
/// Currently previewed file (relative path) and its contents.
|
|
selected_file: Option<SharedString>,
|
|
files: HashMap<String, FileContent>,
|
|
/// Reads in flight, to avoid duplicate loads.
|
|
loading_files: HashSet<String>,
|
|
/// Latest commit touching a previewed file (or the README), keyed by path.
|
|
commits: HashMap<String, FileCommit>,
|
|
/// Commit queries in flight, to avoid duplicate loads.
|
|
loading_commits: HashSet<String>,
|
|
/// A clone/fetch is in flight.
|
|
loading: bool,
|
|
error: Option<SharedString>,
|
|
focus_handle: FocusHandle,
|
|
tasks: Vec<Task<Result<(), Error>>>,
|
|
}
|
|
|
|
impl RepoDetailView {
|
|
pub fn new(initial: Announcement, window: &mut Window, cx: &mut Context<Self>) -> Self {
|
|
let store = cx.new(|cx| RepoStore::new(initial.addr(), cx));
|
|
let tree_state = cx.new(|cx| TreeState::new(cx));
|
|
|
|
// Defer loading the repository until the window is ready.
|
|
cx.defer_in(window, |this, _window, cx| {
|
|
this.load_repo(cx);
|
|
});
|
|
|
|
Self {
|
|
store,
|
|
initial,
|
|
tree_state,
|
|
worktree: None,
|
|
md: None,
|
|
code: None,
|
|
readme_name: None,
|
|
selected_file: None,
|
|
files: HashMap::new(),
|
|
loading_files: HashSet::new(),
|
|
commits: HashMap::new(),
|
|
loading_commits: HashSet::new(),
|
|
loading: true,
|
|
error: None,
|
|
focus_handle: cx.focus_handle(),
|
|
tasks: Vec::new(),
|
|
}
|
|
}
|
|
|
|
/// Clone (or fetch) the repository and populate the file explorer.
|
|
fn load_repo(&mut self, cx: &mut Context<Self>) {
|
|
self.loading = true;
|
|
self.error = None;
|
|
cx.notify();
|
|
|
|
let cache = GitStore::global(cx).cache().clone();
|
|
let addr = self.initial.addr();
|
|
let clone_urls: Vec<String> = self.initial.clone.iter().map(ToString::to_string).collect();
|
|
|
|
let load = cx.background_spawn(async move {
|
|
let repo = cache.ensure_clone(&addr, &clone_urls)?;
|
|
let entries = signed_git::worktree_entries(&repo)?;
|
|
let readme_path = signed_git::find_readme(&repo)?;
|
|
let readme = match &readme_path {
|
|
Some(path) => signed_git::worktree_read(&repo, path)?,
|
|
None => None,
|
|
};
|
|
let worktree = repo.workdir().map(Path::to_path_buf);
|
|
|
|
Ok::<_, Error>((entries, readme_path, readme, worktree))
|
|
});
|
|
|
|
let task = cx.spawn(async move |this, cx| {
|
|
let result = load.await;
|
|
|
|
this.update(cx, |this, cx| {
|
|
match result {
|
|
Ok((entries, readme_path, readme, Some(worktree))) => {
|
|
this.worktree = Some(worktree);
|
|
this.tree_state.update(cx, |state, cx| {
|
|
state.set_items(build_tree_items(&entries), cx);
|
|
});
|
|
if let Some((path, bytes)) = readme_path.zip(readme) {
|
|
this.readme_name = Some(path.to_string_lossy().into());
|
|
this.load_commit(&path.to_string_lossy(), cx);
|
|
if let Ok(text) = String::from_utf8(bytes) {
|
|
this.set_markdown(None, &text, cx);
|
|
}
|
|
}
|
|
}
|
|
Ok((_, _, _, None)) => {
|
|
this.error = Some("Repository has no worktree".into());
|
|
}
|
|
Err(error) => {
|
|
this.error = Some(error.to_string().into());
|
|
}
|
|
}
|
|
this.loading = false;
|
|
cx.notify();
|
|
})?;
|
|
|
|
Ok(())
|
|
});
|
|
|
|
self.tasks.push(task);
|
|
}
|
|
|
|
/// Preview the file at `path` (relative to the worktree root).
|
|
fn open_file(&mut self, path: &str, _window: &mut Window, cx: &mut Context<Self>) {
|
|
self.selected_file = Some(path.into());
|
|
|
|
if self.files.contains_key(path) || self.loading_files.contains(path) {
|
|
cx.notify();
|
|
return;
|
|
}
|
|
|
|
// Paths come from our own tree walk, but never trust them: refuse
|
|
// anything that could escape the worktree.
|
|
let rel = Path::new(path);
|
|
let unsafe_path = rel.is_absolute()
|
|
|| rel.components().any(|c| {
|
|
matches!(
|
|
c,
|
|
Component::ParentDir | Component::RootDir | Component::Prefix(_)
|
|
)
|
|
});
|
|
|
|
let Some(worktree) = self.worktree.clone() else {
|
|
return;
|
|
};
|
|
|
|
if unsafe_path {
|
|
return;
|
|
}
|
|
|
|
self.loading_files.insert(path.to_string());
|
|
let path = path.to_string();
|
|
self.load_commit(&path, cx);
|
|
|
|
let task = cx.spawn(async move |this, cx| {
|
|
let path_for_read = path.clone();
|
|
let content = cx
|
|
.background_spawn(async move {
|
|
let full = worktree.join(&path_for_read);
|
|
let bytes = match std::fs::read(&full) {
|
|
Ok(bytes) => bytes,
|
|
Err(error) => return Err(anyhow::anyhow!("{}", error)),
|
|
};
|
|
|
|
let kind = if bytes.len() > MAX_PREVIEW_BYTES {
|
|
FileContent::TooLarge
|
|
} else {
|
|
match String::from_utf8(bytes) {
|
|
Ok(text) => FileContent::Text(text),
|
|
Err(_) => FileContent::Binary,
|
|
}
|
|
};
|
|
Ok::<_, Error>(kind)
|
|
})
|
|
.await;
|
|
|
|
this.update(cx, |this, cx| {
|
|
this.loading_files.remove(&path);
|
|
match content {
|
|
Ok(kind) => {
|
|
if let FileContent::Text(text) = &kind {
|
|
if is_markdown_path(&path) {
|
|
let same = this.md.as_ref().map(|md| md.path.as_deref())
|
|
== Some(Some(path.as_str()));
|
|
if !same {
|
|
this.set_markdown(Some(path.clone().into()), text, cx);
|
|
}
|
|
} else {
|
|
let same = this.code.as_ref().map(|code| code.path.as_str())
|
|
== Some(path.as_str());
|
|
if !same {
|
|
this.set_code(path.clone().into(), text, cx);
|
|
}
|
|
}
|
|
}
|
|
this.files.insert(path, kind);
|
|
}
|
|
Err(error) => {
|
|
this.files
|
|
.insert(path, FileContent::Failed(error.to_string()));
|
|
}
|
|
}
|
|
cx.notify();
|
|
})?;
|
|
|
|
Ok(())
|
|
});
|
|
|
|
self.tasks.push(task);
|
|
}
|
|
|
|
/// Query the latest commit touching `path` on a background task and cache
|
|
/// it in [`Self::commits`], for the file header in the content column.
|
|
fn load_commit(&mut self, path: &str, cx: &mut Context<Self>) {
|
|
if self.commits.contains_key(path) || self.loading_commits.contains(path) {
|
|
return;
|
|
}
|
|
let Some(worktree) = self.worktree.clone() else {
|
|
return;
|
|
};
|
|
|
|
self.loading_commits.insert(path.to_string());
|
|
let path = path.to_string();
|
|
|
|
let task = cx.spawn(async move |this, cx| {
|
|
let path_for_query = path.clone();
|
|
let result = cx
|
|
.background_spawn(async move {
|
|
signed_git::worktree_last_commit(&worktree, Path::new(&path_for_query))
|
|
})
|
|
.await;
|
|
|
|
this.update(cx, |this, cx| {
|
|
this.loading_commits.remove(&path);
|
|
if let Ok(Some(commit)) = result {
|
|
this.commits.insert(path, commit);
|
|
}
|
|
cx.notify();
|
|
})?;
|
|
|
|
Ok(())
|
|
});
|
|
|
|
self.tasks.push(task);
|
|
}
|
|
}
|
|
|
|
impl Panel for RepoDetailView {
|
|
fn panel_name(&self) -> &'static str {
|
|
"repo_detail"
|
|
}
|
|
|
|
fn title(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
|
|
let announcement = self
|
|
.store
|
|
.read(cx)
|
|
.announcement
|
|
.clone()
|
|
.unwrap_or_else(|| self.initial.clone());
|
|
|
|
announcement
|
|
.name
|
|
.clone()
|
|
.unwrap_or_else(|| SharedString::from(announcement.id.clone()))
|
|
}
|
|
}
|
|
|
|
impl EventEmitter<PanelEvent> for RepoDetailView {}
|
|
|
|
impl Focusable for RepoDetailView {
|
|
fn focus_handle(&self, _cx: &App) -> FocusHandle {
|
|
self.focus_handle.clone()
|
|
}
|
|
}
|
|
|
|
impl Render for RepoDetailView {
|
|
fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
|
|
let tree_state = self.tree_state.clone();
|
|
let view = cx.entity().downgrade();
|
|
|
|
let announcement = self
|
|
.store
|
|
.read(cx)
|
|
.announcement
|
|
.clone()
|
|
.unwrap_or_else(|| self.initial.clone());
|
|
|
|
let name = announcement
|
|
.name
|
|
.clone()
|
|
.unwrap_or_else(|| SharedString::from(announcement.id.clone()));
|
|
|
|
let description = announcement
|
|
.description
|
|
.clone()
|
|
.unwrap_or(SharedString::from("No description"));
|
|
|
|
let pane_title = self
|
|
.selected_file
|
|
.clone()
|
|
.or_else(|| self.readme_name.clone())
|
|
.unwrap_or_else(|| "Overview".into());
|
|
|
|
let relays = announcement.relays.clone();
|
|
let web = announcement.web.clone();
|
|
|
|
v_flex()
|
|
.id("repo")
|
|
.size_full()
|
|
.child(
|
|
h_flex()
|
|
.px_4()
|
|
.pt_2()
|
|
.pb_4()
|
|
.w_full()
|
|
.gap_2()
|
|
.items_start()
|
|
.justify_between()
|
|
.border_b_1()
|
|
.border_color(cx.theme().border)
|
|
.child(
|
|
v_flex()
|
|
.flex_1()
|
|
.min_w_0()
|
|
.child(div().font_semibold().child(name))
|
|
.child(
|
|
div()
|
|
.text_xs()
|
|
.text_color(cx.theme().muted_foreground)
|
|
.line_clamp(3)
|
|
.child(description),
|
|
),
|
|
)
|
|
.child(
|
|
h_flex()
|
|
.flex_none()
|
|
.gap_2()
|
|
.justify_end()
|
|
.child(
|
|
DropdownButton::new("relays")
|
|
.button(
|
|
Button::new("relay-trigger")
|
|
.label(format!("{} relays", relays.len()))
|
|
.ghost(),
|
|
)
|
|
.dropdown_menu(move |menu, _window, _cx| {
|
|
let mut menu = menu;
|
|
if relays.is_empty() {
|
|
return menu.item(
|
|
PopupMenuItem::new("No relays").disabled(true),
|
|
);
|
|
}
|
|
for relay in relays.iter() {
|
|
let url = relay.to_string();
|
|
menu = menu.item(
|
|
PopupMenuItem::new(url.clone()).on_click(
|
|
move |_, _, cx| {
|
|
cx.write_to_clipboard(
|
|
ClipboardItem::new_string(url.clone()),
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
menu
|
|
}),
|
|
)
|
|
.child(
|
|
DropdownButton::new("web")
|
|
.button(Button::new("web-trigger").label("Websites").ghost())
|
|
.dropdown_menu(move |menu, _window, _cx| {
|
|
let mut menu = menu;
|
|
if web.is_empty() {
|
|
return menu
|
|
.item(PopupMenuItem::new("No web").disabled(true));
|
|
}
|
|
for url in web.iter() {
|
|
let href = url.to_string();
|
|
menu = menu.item(
|
|
PopupMenuItem::new(href.clone()).on_click(
|
|
move |_, _, cx| {
|
|
cx.open_url(&href);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
menu
|
|
}),
|
|
)
|
|
.child(
|
|
Button::new("link")
|
|
.icon(IconName::ExternalLink)
|
|
.tooltip("Open in gitworkshop.dev")
|
|
.secondary(),
|
|
)
|
|
.child(
|
|
Button::new("clone")
|
|
.icon(CustomIconName::GitClone)
|
|
.tooltip("Clone")
|
|
.primary(),
|
|
),
|
|
),
|
|
)
|
|
.child(
|
|
h_flex()
|
|
.flex_1()
|
|
.w_full()
|
|
.overflow_hidden()
|
|
.child(self.render_tree_column(tree_state, view, cx))
|
|
.child(self.render_content_column(pane_title, cx)),
|
|
)
|
|
}
|
|
}
|