926 lines
38 KiB
Rust
926 lines
38 KiB
Rust
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<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>,
|
|
/// 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<Vec<FileCommit>>,
|
|
/// Commit walk in flight.
|
|
loading_all_commits: bool,
|
|
/// Virtual list state of the Commits tab.
|
|
scroll_handle: VirtualListScrollHandle,
|
|
item_sizes: Rc<Vec<Size<Pixels>>>,
|
|
/// A clone/fetch is in flight.
|
|
loading: bool,
|
|
error: Option<SharedString>,
|
|
/// Commit HEAD currently points to, shown in the header button.
|
|
head_commit: Option<FileCommit>,
|
|
/// Branch selector (header): local branches, searchable.
|
|
branch_select: Entity<ComboboxState<SearchableVec<SharedString>>>,
|
|
/// Tag selector (header): tags, searchable.
|
|
tag_select: Entity<ComboboxState<SearchableVec<SharedString>>>,
|
|
/// 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<Subscription>,
|
|
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));
|
|
|
|
// Empty until the clone completes; populated with the local refs.
|
|
let branch_select: Entity<ComboboxState<SearchableVec<SharedString>>> = cx.new(|cx| {
|
|
ComboboxState::new(
|
|
SearchableVec::new(Vec::<SharedString>::new()),
|
|
Vec::new(),
|
|
window,
|
|
cx,
|
|
)
|
|
.searchable(true)
|
|
});
|
|
let tag_select: Entity<ComboboxState<SearchableVec<SharedString>>> = cx.new(|cx| {
|
|
ComboboxState::new(
|
|
SearchableVec::new(Vec::<SharedString>::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>) {
|
|
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);
|
|
// 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<SharedString> =
|
|
branches.into_iter().map(Into::into).collect();
|
|
let tags: Vec<SharedString> = 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>) {
|
|
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<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 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<Self>) {
|
|
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<Self>,
|
|
) {
|
|
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<ComboboxState<SearchableVec<SharedString>>>,
|
|
previous: &Option<SharedString>,
|
|
window: &mut Window,
|
|
cx: &mut Context<Self>,
|
|
) {
|
|
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<SearchableVec<SharedString>>,
|
|
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<Self>) {
|
|
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<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();
|
|
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),
|
|
})
|
|
}
|
|
}
|