use std::collections::{HashMap, HashSet}; use std::path::{Component, Path, PathBuf}; use std::rc::Rc; use anyhow::Error; use assets::CustomIconName; use gpui::prelude::*; use gpui::{ AnyElement, App, ClipboardItem, Context, Entity, EventEmitter, FocusHandle, Focusable, Pixels, Render, SharedString, Size, Subscription, Task, Window, div, px, size, }; use gpui_component::button::{Button, ButtonVariants, DropdownButton}; use gpui_component::combobox::{Caret, Combobox, ComboboxEvent, ComboboxState, ComboboxTriggerCtx}; use gpui_component::dock::{Panel, PanelEvent}; use gpui_component::menu::PopupMenuItem; use gpui_component::searchable_list::SearchableVec; use gpui_component::tab::{Tab, TabBar}; use gpui_component::tag::Tag; use gpui_component::tree::TreeState; use gpui_component::{ ActiveTheme, Icon, IconName, Sizable, StyledExt, VirtualListScrollHandle, h_flex, v_flex, }; use signed_core::Announcement; use signed_git::FileCommit; use signed_state::{GitStore, RepoStore}; mod browser; mod commits; mod helpers; use browser::{CodeView, FileContent, MAX_PREVIEW_BYTES, MarkdownView}; use commits::COMMIT_ROW_HEIGHT; use helpers::{build_tree_items, is_markdown_path}; /// What kind of ref the header selectors switch to. #[derive(Clone, Copy, PartialEq, Eq)] enum RefKind { /// A local branch (`refs/heads/*`); HEAD stays attached. Branch, /// A tag (`refs/tags/*`); HEAD becomes detached. Tag, } /// 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, /// 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, /// Root of the local clone, for reading files on demand. worktree: Option, /// Markdown document currently in the preview pane (README or a file). md: Option, /// Code file currently in the preview pane. code: Option, readme_name: Option, /// Currently previewed file (relative path) and its contents. selected_file: Option, files: HashMap, /// Reads in flight, to avoid duplicate loads. loading_files: HashSet, /// Latest commit touching a previewed file (or the README), keyed by path. commits: HashMap, /// Commit queries in flight, to avoid duplicate loads. loading_commits: HashSet, /// Active header tab: 0 = Files (tree), 1 = Commits. active_tab: usize, /// All commits reachable from HEAD, newest first; `None` until the /// walk finishes (or fails). all_commits: Option>, /// Commit walk in flight. loading_all_commits: bool, /// Virtual list state of the Commits tab. scroll_handle: VirtualListScrollHandle, item_sizes: Rc>>, /// A clone/fetch is in flight. loading: bool, error: Option, /// Commit HEAD currently points to, shown in the header button. head_commit: Option, /// Branch selector (header): local branches, searchable. branch_select: Entity>>, /// Tag selector (header): tags, searchable. tag_select: Entity>>, /// A branch/tag switch is in flight (checkout plus explorer reload). switching_ref: bool, /// Bumped on every branch/tag switch; in-flight loads tagged with an /// older generation are discarded when they complete. ref_generation: u64, /// Subscriptions keeping the selectors' confirm events alive. _subscriptions: Vec, focus_handle: FocusHandle, tasks: Vec>>, } impl RepoDetailView { pub fn new(initial: Announcement, window: &mut Window, cx: &mut Context) -> Self { let store = cx.new(|cx| RepoStore::new(initial.addr(), cx)); let tree_state = cx.new(|cx| TreeState::new(cx)); // Empty until the clone completes; populated with the local refs. let branch_select: Entity>> = cx.new(|cx| { ComboboxState::new( SearchableVec::new(Vec::::new()), Vec::new(), window, cx, ) .searchable(true) }); let tag_select: Entity>> = cx.new(|cx| { ComboboxState::new( SearchableVec::new(Vec::::new()), Vec::new(), window, cx, ) .searchable(true) }); let subscriptions = vec![ cx.subscribe_in(&branch_select, window, |this, _state, event, window, cx| { // `Change` fires only when the selection actually changed // (picking the already-selected branch emits nothing), so a // confirmed value always means a switch. if let ComboboxEvent::Change(values) = event && let Some(name) = values.first() { this.switch_ref(RefKind::Branch, name.clone(), window, cx); } }), cx.subscribe_in(&tag_select, window, |this, _state, event, window, cx| { if let ComboboxEvent::Change(values) = event && let Some(name) = values.first() { this.switch_ref(RefKind::Tag, name.clone(), window, cx); } }), ]; // Defer loading the repository until the window is ready. cx.defer_in(window, |this, window, cx| { this.load_repo(window, 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(), active_tab: 0, all_commits: None, loading_all_commits: false, scroll_handle: VirtualListScrollHandle::new(), item_sizes: Rc::new(Vec::new()), loading: true, error: None, head_commit: None, branch_select, tag_select, switching_ref: false, ref_generation: 0, _subscriptions: subscriptions, focus_handle: cx.focus_handle(), tasks: Vec::new(), } } /// Clone (or fetch) the repository and populate the file explorer. fn load_repo(&mut self, window: &mut Window, cx: &mut Context) { self.loading = true; self.error = None; cx.notify(); let cache = GitStore::global(cx).cache().clone(); let addr = self.initial.addr(); let clone_urls: Vec = 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); // Ref listing is auxiliary UI: a broken ref must not prevent the // explorer from loading, so failures degrade to empty selectors. let (branches, tags, current_branch) = match &worktree { Some(worktree) => ( signed_git::worktree_branches(worktree).unwrap_or_default(), signed_git::worktree_tags(worktree).unwrap_or_default(), signed_git::current_branch(&repo).unwrap_or(None), ), None => (Vec::new(), Vec::new(), None), }; let head_commit = signed_git::head_commit(&repo).unwrap_or(None); Ok::<_, Error>(( entries, readme_path, readme, worktree, branches, tags, current_branch, head_commit, )) }); let task = cx.spawn_in(window, async move |this, cx| { let result = load.await; this.update_in(cx, |this, window, cx| { match result { Ok(( entries, readme_path, readme, Some(worktree), branches, tags, current_branch, head_commit, )) => { this.worktree = Some(worktree); this.head_commit = head_commit; this.tree_state.update(cx, |state, cx| { state.set_items(build_tree_items(&entries), cx); }); // Populate the branch/tag selectors with the local // refs, selecting the branch HEAD points to. let branches: Vec = branches.into_iter().map(Into::into).collect(); let tags: Vec = tags.into_iter().map(Into::into).collect(); this.branch_select.update(cx, |state, cx| { state.set_items(SearchableVec::from(branches), window, cx); if let Some(branch) = current_branch { let branch: SharedString = branch.into(); state.set_selected_values(&[branch], window, cx); } }); this.tag_select.update(cx, |state, cx| { state.set_items(SearchableVec::from(tags), window, cx); }); this.load_all_commits(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.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 generation = self.ref_generation; 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| { // The worktree was switched while this file was reading; // the result belongs to the previous branch. if generation != this.ref_generation { return; } 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) { 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 generation = self.ref_generation; 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| { if generation != this.ref_generation { return; } this.loading_commits.remove(&path); if let Ok(Some(commit)) = result { this.commits.insert(path, commit); } cx.notify(); })?; Ok(()) }); self.tasks.push(task); } /// Walk all commits reachable from HEAD on a background task, for the /// Commits tab and its total-count badge. fn load_all_commits(&mut self, cx: &mut Context) { if self.loading_all_commits || self.all_commits.is_some() { return; } let Some(worktree) = self.worktree.clone() else { return; }; self.loading_all_commits = true; let generation = self.ref_generation; let task = cx.spawn(async move |this, cx| { let result = cx .background_spawn(async move { signed_git::worktree_all_commits(&worktree) }) .await; this.update(cx, |this, cx| { if generation != this.ref_generation { return; } if let Ok(commits) = result { let count = commits.len(); this.item_sizes = Rc::new(vec![size(px(0.), px(COMMIT_ROW_HEIGHT)); count]); this.all_commits = Some(commits); } this.loading_all_commits = false; cx.notify(); })?; Ok(()) }); self.tasks.push(task); } /// Check out `name` (a branch or tag picked in the header) and refresh /// the explorer once the switch completes. fn switch_ref( &mut self, kind: RefKind, name: SharedString, window: &mut Window, cx: &mut Context, ) { if self.switching_ref { return; } let Some(worktree) = self.worktree.clone() else { return; }; // Branches and tags are mutually exclusive states of HEAD: selecting // one clears the other selector. Remember the previous selections so // they can be restored if the checkout fails. let previous_branch = self.branch_select.read(cx).selected_value(); let previous_tag = self.tag_select.read(cx).selected_value(); match kind { RefKind::Branch => { self.tag_select .update(cx, |state, cx| state.clear_selection(cx)); } RefKind::Tag => { self.branch_select .update(cx, |state, cx| state.clear_selection(cx)); } } self.switching_ref = true; // In-flight loads of the previous branch are discarded when they // complete. self.ref_generation += 1; cx.notify(); let checkout_name = name.clone(); let task = cx.spawn_in(window, async move |this, cx| { let result = cx .background_spawn(async move { match kind { RefKind::Branch => { signed_git::worktree_checkout_branch(&worktree, &checkout_name) } RefKind::Tag => { signed_git::worktree_checkout_tag(&worktree, &checkout_name) } } }) .await; this.update_in(cx, |this, window, cx| { match result { Ok(()) => this.reload_worktree(cx), Err(error) => { this.error = Some(format!("Failed to check out {name}: {error}").into()); this.switching_ref = false; this.restore_selection(&this.branch_select, &previous_branch, window, cx); this.restore_selection(&this.tag_select, &previous_tag, window, cx); } } cx.notify(); })?; Ok(()) }); self.tasks.push(task); } /// Restore a selector to `previous`, or clear it (after a failed switch). fn restore_selection( &self, select: &Entity>>, previous: &Option, window: &mut Window, cx: &mut Context, ) { select.update(cx, |state, cx| match previous { Some(value) => state.set_selected_values(std::slice::from_ref(value), window, cx), None => state.clear_selection(cx), }); } /// Trigger body for the branch/tag selectors: the kind icon, the /// selection (or placeholder) and the caret. `Combobox` replaces its /// default trigger entirely, which is the only way to show an icon /// inside the trigger label. fn render_ref_trigger( ctx: &ComboboxTriggerCtx>, icon: CustomIconName, cx: &App, ) -> AnyElement { let muted = cx.theme().muted_foreground; h_flex() .w_full() .min_w_0() .gap_1() .items_center() .child(Icon::new(icon).small().flex_shrink_0()) .child( div() .flex_1() .min_w_0() .overflow_hidden() .text_ellipsis() .whitespace_nowrap() .when(ctx.selection.is_empty(), |this| this.text_color(muted)) .child( ctx.selection .first() .map(|(_, item)| item.clone()) .or_else(|| ctx.placeholder.cloned()) .unwrap_or_default(), ), ) .child(Caret::new(ctx.size).text_color(muted)) .into_any_element() } /// Refresh the file explorer, preview pane and commit list after a /// successful branch or tag switch. The selectors were already updated /// by [`Self::switch_ref`]; [`Self::switching_ref`] stays set until this /// reload finishes, so a second switch cannot interleave. fn reload_worktree(&mut self, cx: &mut Context) { let Some(worktree) = self.worktree.clone() else { return; }; let task = cx.spawn(async move |this, cx| { let result = cx .background_spawn(async move { signed_git::worktree_snapshot(&worktree) }) .await; this.update(cx, |this, cx| { this.switching_ref = false; match result { Ok(snapshot) => { this.head_commit = snapshot.head_commit; // Rebuild the tree from scratch: entries of the // previous branch are gone, and with them the // expansion state. this.tree_state.update(cx, |state, cx| { state.set_items(build_tree_items(&snapshot.entries), cx); }); // Drop cached previews and commits of the old branch. this.selected_file = None; this.files.clear(); this.loading_files.clear(); this.commits.clear(); this.loading_commits.clear(); this.md = None; this.code = None; this.readme_name = None; this.all_commits = None; this.loading_all_commits = false; if let Some((path, bytes)) = snapshot.readme_path.zip(snapshot.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); } } this.load_all_commits(cx); } Err(error) => { this.error = Some(error.to_string().into()); this.head_commit = None; // The tree may show files that no longer exist. this.tree_state.update(cx, |state, cx| { state.set_items(Vec::new(), cx); }); } } 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) -> 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 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) -> 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(); let commits_count = self.all_commits.as_ref().map(Vec::len); let worktree_empty = self.switching_ref || self.worktree.is_none(); v_flex() .id("repo") .size_full() .child( v_flex() .px_4() .pt_2() .pb_2() .w_full() .gap_8() .border_b_1() .border_color(cx.theme().border) .child( h_flex() .w_full() .gap_2() .items_start() .justify_between() .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) .text_ellipsis() .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() .items_center() .child( TabBar::new("repo-tabs") .segmented() .selected_index(self.active_tab) .child(Tab::new().label("Files")) .child(Tab::new().label("Commits").when_some( commits_count, |this, count| { this.suffix( Tag::secondary() .xsmall() .mr_1() .child(SharedString::from(count.to_string())), ) }, )) .on_click(cx.listener(|this, index, _window, cx| { this.active_tab = *index; cx.notify(); })), ) .child( h_flex() .flex_1() .gap_2() .justify_end() .child( div().w(px(120.)).child( Combobox::new(&self.branch_select) .placeholder("Branch") .appearance(false) .menu_width(px(200.)) .disabled(worktree_empty) .bg(cx.theme().muted) .rounded(cx.theme().radius) .render_trigger(|ctx, _window, cx| { Self::render_ref_trigger( ctx, CustomIconName::GitBranch, cx, ) }), ), ) .child( div().w(px(120.)).child( Combobox::new(&self.tag_select) .placeholder("Tag") .appearance(false) .menu_width(px(200.)) .disabled(worktree_empty) .bg(cx.theme().muted) .rounded(cx.theme().radius) .render_trigger(|ctx, _window, cx| { Self::render_ref_trigger( ctx, CustomIconName::Tag, cx, ) }), ), ) .child( Button::new("enc") .secondary() .when_some(self.head_commit.as_ref(), |this, commit| { this.child( div() .text_xs() .text_color(cx.theme().muted_foreground) .child(SharedString::from(&commit.id)), ) .child( div() .max_w(px(200.)) .overflow_hidden() .text_ellipsis() .whitespace_nowrap() .text_xs() .child(SharedString::from(&commit.summary)), ) }) .tooltip( self.head_commit .as_ref() .map_or_else(SharedString::default, |commit| { commit.summary.clone().into() }), ), ), ), ), ) .child(match self.active_tab { 0 => 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)) .into_any_element(), _ => self.render_commits_tab(cx), }) } }