Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

git: Git Panel UI, continued (#22960)

Browse source 
TODO:

- [ ] Investigate incorrect hit target for `stage all` button
- [ ] Add top level context menu
- [ ] Add entry context menus
- [x] Show paths in list view
- [ ] For now, `enter` can just open the file
- [ ] 🐞: Hover deadzone in list caused by scrollbar
- [x] 🐞: Incorrect status/nothing shown when multiple worktrees are
added

---

This PR continues work on the feature flagged git panel.

Changes:
- Defines and wires up git panel actions & keybindings
- Re-scopes some actions from `git_ui` -> `git`.
- General git actions (StageAll, CommitChanges, ...) are scoped to
`git`.
- Git panel specific actions (Close, FocusCommitEditor, ...) are scoped
to `git_panel.
- Staging actions & UI are now connected to git!
- Unify more reusable git status into the GitState global over being
tied to the panel directly.
- Uses the new git status codepaths instead of filtering all workspace
entries

Release Notes:

- N/A

---------

Co-authored-by: Cole Miller <53574922+cole-miller@users.noreply.github.com>
Co-authored-by: Cole Miller <cole@zed.dev>
This commit is contained in:
Nate Butler 2025-01-13 11:47:09 -05:00 • committed by GitHub
parent 1c6dd03e50
commit 102e70816c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
13 changed files with 1006 additions and 840 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Cargo.lock generated
View file

@ -5113,6 +5113,7 @@ dependencies = [
"collections",
"db",
"editor",
"futures 0.3.31",
"git",
"gpui",
"language",
@ -5123,6 +5124,7 @@ dependencies = [
"serde_derive",
"serde_json",
"settings",
"sum_tree",
"theme",
"ui",
"util",

32
assets/keymaps/default-macos.json
View file

@ -682,6 +682,38 @@
"space": "project_panel::Open"
}
},
{
"context": "GitPanel && !CommitEditor",
"use_key_equivalents": true,
"bindings": {
"escape": "git_panel::Close"
}
},
{
"context": "GitPanel && ChangesList",
"use_key_equivalents": true,
"bindings": {
"up": "menu::SelectPrev",
"down": "menu::SelectNext",
"cmd-up": "menu::SelectFirst",
"cmd-down": "menu::SelectLast",
"enter": "menu::Confirm",
"space": "git::ToggleStaged",
"cmd-shift-space": "git::StageAll",
"ctrl-shift-space": "git::UnstageAll",
"alt-down": "git_panel::FocusEditor"
}
},
{
"context": "GitPanel && CommitEditor > Editor",
"use_key_equivalents": true,
"bindings": {
"alt-up": "git_panel::FocusChanges",
"escape": "git_panel::FocusChanges",
"cmd-enter": "git::CommitChanges",
"cmd-alt-enter": "git::CommitAllChanges"
}
},
{
"context": "CollabPanel && not_editing",
"use_key_equivalents": true,

2
crates/collab/src/tests/random_project_collaboration_tests.rs
View file

@ -1221,7 +1221,7 @@ impl RandomizedTest for ProjectCollaborationTest {
id,
guest_project.remote_id(),
);
assert_eq!(guest_snapshot.repositories().collect::<Vec<_>>(), host_snapshot.repositories().collect::<Vec<_>>(),
assert_eq!(guest_snapshot.repositories().iter().collect::<Vec<_>>(), host_snapshot.repositories().iter().collect::<Vec<_>>(),
"{} has different repositories than the host for worktree {:?} and project {:?}",
client.username,
host_snapshot.abs_path(),

3
crates/editor/src/git/project_diff.rs
View file

@ -197,9 +197,10 @@ impl ProjectDiffEditor {
let snapshot = worktree.read(cx).snapshot();
let applicable_entries = snapshot
.repositories()
.iter()
.flat_map(|entry| {
entry.status().map(|git_entry| {
(git_entry.status, entry.join(git_entry.repo_path))
(git_entry.combined_status(), entry.join(git_entry.repo_path))
})
})
.filter_map(|(status, path)| {

73
crates/git/src/repository.rs
View file

@ -1,6 +1,7 @@
use crate::status::GitStatusPair;
use crate::GitHostingProviderRegistry;
use crate::{blame::Blame, status::GitStatus};
use anyhow::{Context, Result};
use anyhow::{anyhow, Context, Result};
use collections::{HashMap, HashSet};
use git2::BranchType;
use gpui::SharedString;
@ -15,6 +16,7 @@ use std::{
sync::Arc,
};
use sum_tree::MapSeekTarget;
use util::command::new_std_command;
use util::ResultExt;
#[derive(Clone, Debug, Hash, PartialEq)]
@ -51,6 +53,8 @@ pub trait GitRepository: Send + Sync {
/// Returns the path to the repository, typically the `.git` folder.
fn dot_git_dir(&self) -> PathBuf;
fn update_index(&self, stage: &[RepoPath], unstage: &[RepoPath]) -> Result<()>;
}
impl std::fmt::Debug for dyn GitRepository {
@ -152,7 +156,7 @@ impl GitRepository for RealGitRepository {
Ok(_) => Ok(true),
Err(e) => match e.code() {
git2::ErrorCode::NotFound => Ok(false),
_ => Err(anyhow::anyhow!(e)),
_ => Err(anyhow!(e)),
},
}
}
@ -196,7 +200,7 @@ impl GitRepository for RealGitRepository {
repo.set_head(
revision
.name()
.ok_or_else(|| anyhow::anyhow!("Branch name could not be retrieved"))?,
.ok_or_else(|| anyhow!("Branch name could not be retrieved"))?,
)?;
Ok(())
}
@ -228,6 +232,36 @@ impl GitRepository for RealGitRepository {
self.hosting_provider_registry.clone(),
)
}
fn update_index(&self, stage: &[RepoPath], unstage: &[RepoPath]) -> Result<()> {
let working_directory = self
.repository
.lock()
.workdir()
.context("failed to read git work directory")?
.to_path_buf();
if !stage.is_empty() {
let add = new_std_command(&self.git_binary_path)
.current_dir(&working_directory)
.args(["add", "--"])
.args(stage.iter().map(|p| p.as_ref()))
.status()?;
if !add.success() {
return Err(anyhow!("Failed to stage files: {add}"));
}
}
if !unstage.is_empty() {
let rm = new_std_command(&self.git_binary_path)
.current_dir(&working_directory)
.args(["restore", "--staged", "--"])
.args(unstage.iter().map(|p| p.as_ref()))
.status()?;
if !rm.success() {
return Err(anyhow!("Failed to unstage files: {rm}"));
}
}
Ok(())
}
}
#[derive(Debug, Clone)]
@ -298,18 +332,24 @@ impl GitRepository for FakeGitRepository {
let mut entries = state
.worktree_statuses
.iter()
.filter_map(|(repo_path, status)| {
.filter_map(|(repo_path, status_worktree)| {
if path_prefixes
.iter()
.any(|path_prefix| repo_path.0.starts_with(path_prefix))
{
Some((repo_path.to_owned(), *status))
Some((
repo_path.to_owned(),
GitStatusPair {
index_status: None,
worktree_status: Some(*status_worktree),
},
))
} else {
None
}
})
.collect::<Vec<_>>();
entries.sort_unstable_by(|a, b| a.0.cmp(&b.0));
entries.sort_unstable_by(|(a, _), (b, _)| a.cmp(&b));
Ok(GitStatus {
entries: entries.into(),
@ -363,6 +403,10 @@ impl GitRepository for FakeGitRepository {
.with_context(|| format!("failed to get blame for {:?}", path))
.cloned()
}
fn update_index(&self, _stage: &[RepoPath], _unstage: &[RepoPath]) -> Result<()> {
unimplemented!()
}
}
fn check_path_to_repo_path_errors(relative_file_path: &Path) -> Result<()> {
@ -398,6 +442,7 @@ fn check_path_to_repo_path_errors(relative_file_path: &Path) -> Result<()> {
pub enum GitFileStatus {
Added,
Modified,
// TODO conflicts should be represented by the GitStatusPair
Conflict,
Deleted,
Untracked,
@ -426,6 +471,16 @@ impl GitFileStatus {
_ => None,
}
}
pub fn from_byte(byte: u8) -> Option<Self> {
match byte {
b'M' => Some(GitFileStatus::Modified),
b'A' => Some(GitFileStatus::Added),
b'D' => Some(GitFileStatus::Deleted),
b'?' => Some(GitFileStatus::Untracked),
_ => None,
}
}
}
pub static WORK_DIRECTORY_REPO_PATH: LazyLock<RepoPath> =
@ -453,6 +508,12 @@ impl RepoPath {
}
}
impl std::fmt::Display for RepoPath {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.0.to_string_lossy().fmt(f)
}
}
impl From<&Path> for RepoPath {
fn from(value: &Path) -> Self {
RepoPath::new(value.into())

65
crates/git/src/status.rs
View file

@ -2,9 +2,33 @@ use crate::repository::{GitFileStatus, RepoPath};
use anyhow::{anyhow, Result};
use std::{path::Path, process::Stdio, sync::Arc};
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct GitStatusPair {
// Not both `None`.
pub index_status: Option<GitFileStatus>,
pub worktree_status: Option<GitFileStatus>,
}
impl GitStatusPair {
pub fn is_staged(&self) -> Option<bool> {
match (self.index_status, self.worktree_status) {
(Some(_), None) => Some(true),
(None, Some(_)) => Some(false),
(Some(GitFileStatus::Untracked), Some(GitFileStatus::Untracked)) => Some(false),
(Some(_), Some(_)) => None,
(None, None) => unreachable!(),
}
}
// TODO reconsider uses of this
pub fn combined(&self) -> GitFileStatus {
self.index_status.or(self.worktree_status).unwrap()
}
}
#[derive(Clone)]
pub struct GitStatus {
pub entries: Arc<[(RepoPath, GitFileStatus)]>,
pub entries: Arc<[(RepoPath, GitStatusPair)]>,
}
impl GitStatus {
@ -20,6 +44,7 @@ impl GitStatus {
"status",
"--porcelain=v1",
"--untracked-files=all",
"--no-renames",
"-z",
])
.args(path_prefixes.iter().map(|path_prefix| {
@ -47,36 +72,32 @@ impl GitStatus {
let mut entries = stdout
.split('\0')
.filter_map(|entry| {
if entry.is_char_boundary(3) {
let (status, path) = entry.split_at(3);
let status = status.trim();
let sep = entry.get(2..3)?;
if sep != " " {
return None;
};
let path = &entry[3..];
let status = entry[0..2].as_bytes();
let index_status = GitFileStatus::from_byte(status[0]);
let worktree_status = GitFileStatus::from_byte(status[1]);
if (index_status, worktree_status) == (None, None) {
return None;
}
let path = RepoPath(Path::new(path).into());
Some((
RepoPath(Path::new(path).into()),
match status {
"A" => GitFileStatus::Added,
"M" => GitFileStatus::Modified,
"D" => GitFileStatus::Deleted,
"??" => GitFileStatus::Untracked,
_ => return None,
path,
GitStatusPair {
index_status,
worktree_status,
},
))
} else {
None
}
})
.collect::<Vec<_>>();
entries.sort_unstable_by(|a, b| a.0.cmp(&b.0));
entries.sort_unstable_by(|(a, _), (b, _)| a.cmp(&b));
Ok(Self {
entries: entries.into(),
})
}
pub fn get(&self, path: &Path) -> Option<GitFileStatus> {
self.entries
.binary_search_by(|(repo_path, _)| repo_path.0.as_ref().cmp(path))
.ok()
.map(|index| self.entries[index].1)
}
}
impl Default for GitStatus {

2
crates/git_ui/Cargo.toml
View file

@ -17,6 +17,7 @@ anyhow.workspace = true
collections.workspace = true
db.workspace = true
editor.workspace = true
futures.workspace = true
git.workspace = true
gpui.workspace = true
language.workspace = true
@ -27,6 +28,7 @@ serde.workspace = true
serde_derive.workspace = true
serde_json.workspace = true
settings.workspace = true
sum_tree.workspace = true
theme.workspace = true
ui.workspace = true
util.workspace = true

45
crates/git_ui/TODO.md
View file

@ -1,45 +0,0 @@
### General
- [x] Disable staging and committing actions for read-only projects
### List
- [x] Add uniform list
- [x] Git status item
- [ ] Directory item
- [x] Scrollbar
- [ ] Add indent size setting
- [ ] Add tree settings
### List Items
- [x] Checkbox for staging
- [x] Git status icon
- [ ] Context menu
- [ ] Discard Changes
- ---
- [ ] Ignore
- [ ] Ignore directory
- ---
- [ ] Copy path
- [ ] Copy relative path
- ---
- [ ] Reveal in Finder
### Commit Editor
- [ ] Add commit editor
- [ ] Add commit message placeholder & add commit message to store
- [ ] Add a way to get the current collaborators & automatically add them to the commit message as co-authors
- [ ] Add action to clear commit message
- [x] Swap commit button between "Commit" and "Commit All" based on modifier key
### Component Updates
- [ ] ChangedLineCount (new)
- takes `lines_added: usize, lines_removed: usize`, returns a added/removed badge
- [x] GitStatusIcon (new)
- [ ] Checkbox
- update checkbox design
- [ ] ScrollIndicator
- shows a gradient overlay when more content is available to be scrolled

1182
crates/git_ui/src/git_panel.rs
View file

File diff suppressed because it is too large Load diff

256
crates/git_ui/src/git_ui.rs
View file

@ -1,56 +1,282 @@
use ::settings::Settings;
use git::repository::GitFileStatus;
use gpui::{actions, AppContext, Context, Global, Hsla, Model};
use collections::HashMap;
use futures::{future::FusedFuture, select, FutureExt};
use git::repository::{GitFileStatus, GitRepository, RepoPath};
use gpui::{actions, AppContext, Context, Global, Hsla, Model, ModelContext};
use project::{Project, WorktreeId};
use settings::GitPanelSettings;
use std::sync::mpsc;
use std::{
pin::{pin, Pin},
sync::Arc,
time::Duration,
};
use sum_tree::SumTree;
use ui::{Color, Icon, IconName, IntoElement, SharedString};
use worktree::RepositoryEntry;
pub mod git_panel;
mod settings;
const GIT_TASK_DEBOUNCE: Duration = Duration::from_millis(50);
actions!(
git_ui,
git,
[
StageFile,
UnstageFile,
ToggleStaged,
// Revert actions are currently in the editor crate:
// editor::RevertFile,
// editor::RevertSelectedHunks
StageAll,
UnstageAll,
RevertAll,
CommitStagedChanges,
CommitChanges,
CommitAllChanges,
ClearMessage
ClearCommitMessage
]
);
pub fn init(cx: &mut AppContext) {
GitPanelSettings::register(cx);
let git_state = cx.new_model(|_cx| GitState::new());
let git_state = cx.new_model(GitState::new);
cx.set_global(GlobalGitState(git_state));
}
#[derive(Default, Debug, PartialEq, Eq, Clone)]
pub enum GitViewMode {
#[default]
List,
Tree,
}
struct GlobalGitState(Model<GitState>);
impl Global for GlobalGitState {}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum StatusAction {
Stage,
Unstage,
}
pub struct GitState {
/// The current commit message being composed.
commit_message: Option<SharedString>,
/// When a git repository is selected, this is used to track which repository's changes
/// are currently being viewed or modified in the UI.
active_repository: Option<(WorktreeId, RepositoryEntry, Arc<dyn GitRepository>)>,
updater_tx: mpsc::Sender<(Arc<dyn GitRepository>, Vec<RepoPath>, StatusAction)>,
all_repositories: HashMap<WorktreeId, SumTree<RepositoryEntry>>,
list_view_mode: GitViewMode,
}
impl GitState {
pub fn new() -> Self {
pub fn new(cx: &mut ModelContext<'_, Self>) -> Self {
let (updater_tx, updater_rx) = mpsc::channel();
cx.spawn(|_, cx| async move {
// Long-running task to periodically update git indices based on messages from the panel.
// We read messages from the channel in batches that refer to the same repository.
// When we read a message whose repository is different from the current batch's repository,
// the batch is finished, and since we can't un-receive this last message, we save it
// to begin the next batch.
let mut leftover_message: Option<(
Arc<dyn GitRepository>,
Vec<RepoPath>,
StatusAction,
)> = None;
let mut git_task = None;
loop {
let mut timer = cx.background_executor().timer(GIT_TASK_DEBOUNCE).fuse();
let _result = {
let mut task: Pin<&mut dyn FusedFuture<Output = anyhow::Result<()>>> =
match git_task.as_mut() {
Some(task) => pin!(task),
// If no git task is running, just wait for the timeout.
None => pin!(std::future::pending().fuse()),
};
select! {
result = task => {
// Task finished.
git_task = None;
Some(result)
}
_ = timer => None,
}
};
// TODO handle failure of the git command
if git_task.is_none() {
// No git task running now; let's see if we should launch a new one.
let mut to_stage = Vec::new();
let mut to_unstage = Vec::new();
let mut current_repo = leftover_message.as_ref().map(|msg| msg.0.clone());
for (git_repo, paths, action) in leftover_message
.take()
.into_iter()
.chain(updater_rx.try_iter())
{
if current_repo
.as_ref()
.map_or(false, |repo| !Arc::ptr_eq(repo, &git_repo))
{
// End of a batch, save this for the next one.
leftover_message = Some((git_repo.clone(), paths, action));
break;
} else if current_repo.is_none() {
// Start of a batch.
current_repo = Some(git_repo);
}
if action == StatusAction::Stage {
to_stage.extend(paths);
} else {
to_unstage.extend(paths);
}
}
// TODO handle the same path being staged and unstaged
if to_stage.is_empty() && to_unstage.is_empty() {
continue;
}
if let Some(git_repo) = current_repo {
git_task = Some(
cx.background_executor()
.spawn(async move { git_repo.update_index(&to_stage, &to_unstage) })
.fuse(),
);
}
}
}
})
.detach();
GitState {
commit_message: None,
active_repository: None,
updater_tx,
list_view_mode: GitViewMode::default(),
all_repositories: HashMap::default(),
}
}
pub fn set_message(&mut self, message: Option<SharedString>) {
self.commit_message = message;
}
pub fn clear_message(&mut self) {
self.commit_message = None;
}
pub fn get_global(cx: &mut AppContext) -> Model<GitState> {
cx.global::<GlobalGitState>().0.clone()
}
pub fn activate_repository(
&mut self,
worktree_id: WorktreeId,
active_repository: RepositoryEntry,
git_repo: Arc<dyn GitRepository>,
) {
self.active_repository = Some((worktree_id, active_repository, git_repo));
}
pub fn active_repository(
&self,
) -> Option<&(WorktreeId, RepositoryEntry, Arc<dyn GitRepository>)> {
self.active_repository.as_ref()
}
pub fn commit_message(&mut self, message: Option<SharedString>) {
self.commit_message = message;
}
pub fn clear_commit_message(&mut self) {
self.commit_message = None;
}
pub fn stage_entry(&mut self, repo_path: RepoPath) {
if let Some((_, _, git_repo)) = self.active_repository.as_ref() {
let _ = self
.updater_tx
.send((git_repo.clone(), vec![repo_path], StatusAction::Stage));
}
}
pub fn unstage_entry(&mut self, repo_path: RepoPath) {
if let Some((_, _, git_repo)) = self.active_repository.as_ref() {
let _ =
self.updater_tx
.send((git_repo.clone(), vec![repo_path], StatusAction::Unstage));
}
}
pub fn stage_entries(&mut self, entries: Vec<RepoPath>) {
if let Some((_, _, git_repo)) = self.active_repository.as_ref() {
let _ = self
.updater_tx
.send((git_repo.clone(), entries, StatusAction::Stage));
}
}
fn act_on_all(&mut self, action: StatusAction) {
if let Some((_, active_repository, git_repo)) = self.active_repository.as_ref() {
let _ = self.updater_tx.send((
git_repo.clone(),
active_repository
.status()
.map(|entry| entry.repo_path)
.collect(),
action,
));
}
}
pub fn stage_all(&mut self) {
self.act_on_all(StatusAction::Stage);
}
pub fn unstage_all(&mut self) {
self.act_on_all(StatusAction::Unstage);
}
}
pub fn first_worktree_repository(
project: &Model<Project>,
worktree_id: WorktreeId,
cx: &mut AppContext,
) -> Option<(RepositoryEntry, Arc<dyn GitRepository>)> {
project
.read(cx)
.worktree_for_id(worktree_id, cx)
.and_then(|worktree| {
let snapshot = worktree.read(cx).snapshot();
let repo = snapshot.repositories().iter().next()?.clone();
let git_repo = worktree
.read(cx)
.as_local()?
.get_local_repo(&repo)?
.repo()
.clone();
Some((repo, git_repo))
})
}
pub fn first_repository_in_project(
project: &Model<Project>,
cx: &mut AppContext,
) -> Option<(WorktreeId, RepositoryEntry, Arc<dyn GitRepository>)> {
project.read(cx).worktrees(cx).next().and_then(|worktree| {
let snapshot = worktree.read(cx).snapshot();
let repo = snapshot.repositories().iter().next()?.clone();
let git_repo = worktree
.read(cx)
.as_local()?
.get_local_repo(&repo)?
.repo()
.clone();
Some((snapshot.id(), repo, git_repo))
})
}
const ADDED_COLOR: Hsla = Hsla {

1
crates/ui/src/components/button/button_like.rs
View file

@ -487,6 +487,7 @@ impl RenderOnce for ButtonLike {
self.base
.h_flex()
.id(self.id.clone())
.font_ui(cx)
.group("")
.flex_none()
.h(self.height.unwrap_or(self.size.rems().into()))

81
crates/worktree/src/worktree.rs
View file

@ -21,6 +21,7 @@ use fuzzy::CharBag;
use git::GitHostingProviderRegistry;
use git::{
repository::{GitFileStatus, GitRepository, RepoPath},
status::GitStatusPair,
COOKIES, DOT_GIT, FSMONITOR_DAEMON, GITIGNORE,
};
use gpui::{
@ -193,8 +194,8 @@ pub struct RepositoryEntry {
/// - my_sub_folder_1/project_root/changed_file_1
/// - my_sub_folder_2/changed_file_2
pub(crate) statuses_by_path: SumTree<StatusEntry>,
pub(crate) work_directory_id: ProjectEntryId,
pub(crate) work_directory: WorkDirectory,
pub work_directory_id: ProjectEntryId,
pub work_directory: WorkDirectory,
pub(crate) branch: Option<Arc<str>>,
}
@ -225,6 +226,12 @@ impl RepositoryEntry {
self.statuses_by_path.iter().cloned()
}
pub fn status_for_path(&self, path: &RepoPath) -> Option<StatusEntry> {
self.statuses_by_path
.get(&PathKey(path.0.clone()), &())
.cloned()
}
pub fn initial_update(&self) -> proto::RepositoryEntry {
proto::RepositoryEntry {
work_directory_id: self.work_directory_id.to_proto(),
@ -234,7 +241,7 @@ impl RepositoryEntry {
.iter()
.map(|entry| proto::StatusEntry {
repo_path: entry.repo_path.to_string_lossy().to_string(),
status: git_status_to_proto(entry.status),
status: status_pair_to_proto(entry.status.clone()),
})
.collect(),
removed_statuses: Default::default(),
@ -259,7 +266,7 @@ impl RepositoryEntry {
current_new_entry = new_statuses.next();
}
Ordering::Equal => {
if new_entry.status != old_entry.status {
if new_entry.combined_status() != old_entry.combined_status() {
updated_statuses.push(new_entry.to_proto());
}
current_old_entry = old_statuses.next();
@ -2360,7 +2367,7 @@ impl Snapshot {
let repo_path = repo.relativize(path).unwrap();
repo.statuses_by_path
.get(&PathKey(repo_path.0), &())
.map(|entry| entry.status)
.map(|entry| entry.combined_status())
})
}
@ -2574,8 +2581,8 @@ impl Snapshot {
.map(|repo| repo.status().collect())
}
pub fn repositories(&self) -> impl Iterator<Item = &RepositoryEntry> {
self.repositories.iter()
pub fn repositories(&self) -> &SumTree<RepositoryEntry> {
&self.repositories
}
/// Get the repository whose work directory corresponds to the given path.
@ -2609,7 +2616,7 @@ impl Snapshot {
entries: impl 'a + Iterator<Item = &'a Entry>,
) -> impl 'a + Iterator<Item = (&'a Entry, Option<&'a RepositoryEntry>)> {
let mut containing_repos = Vec::<&RepositoryEntry>::new();
let mut repositories = self.repositories().peekable();
let mut repositories = self.repositories().iter().peekable();
entries.map(move |entry| {
while let Some(repository) = containing_repos.last() {
if repository.directory_contains(&entry.path) {
@ -3626,14 +3633,31 @@ pub type UpdatedGitRepositoriesSet = Arc<[(Arc<Path>, GitRepositoryChange)]>;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct StatusEntry {
pub repo_path: RepoPath,
pub status: GitFileStatus,
pub status: GitStatusPair,
}
impl StatusEntry {
// TODO revisit uses of this
pub fn combined_status(&self) -> GitFileStatus {
self.status.combined()
}
pub fn index_status(&self) -> Option<GitFileStatus> {
self.status.index_status
}
pub fn worktree_status(&self) -> Option<GitFileStatus> {
self.status.worktree_status
}
pub fn is_staged(&self) -> Option<bool> {
self.status.is_staged()
}
fn to_proto(&self) -> proto::StatusEntry {
proto::StatusEntry {
repo_path: self.repo_path.to_proto(),
status: git_status_to_proto(self.status),
status: status_pair_to_proto(self.status.clone()),
}
}
}
@ -3641,11 +3665,10 @@ impl StatusEntry {
impl TryFrom<proto::StatusEntry> for StatusEntry {
type Error = anyhow::Error;
fn try_from(value: proto::StatusEntry) -> Result<Self, Self::Error> {
Ok(Self {
repo_path: RepoPath(Path::new(&value.repo_path).into()),
status: git_status_from_proto(Some(value.status))
.ok_or_else(|| anyhow!("Unable to parse status value {}", value.status))?,
})
let repo_path = RepoPath(Path::new(&value.repo_path).into());
let status = status_pair_from_proto(value.status)
.ok_or_else(|| anyhow!("Unable to parse status value {}", value.status))?;
Ok(Self { repo_path, status })
}
}
@ -3729,7 +3752,7 @@ impl sum_tree::Item for StatusEntry {
fn summary(&self, _: &<Self::Summary as Summary>::Context) -> Self::Summary {
PathSummary {
max_path: self.repo_path.0.clone(),
item_summary: match self.status {
item_summary: match self.combined_status() {
GitFileStatus::Added => GitStatuses {
added: 1,
..Default::default()
@ -4820,15 +4843,15 @@ impl BackgroundScanner {
for (repo_path, status) in &*status.entries {
paths.remove_repo_path(repo_path);
if cursor.seek_forward(&PathTarget::Path(&repo_path), Bias::Left, &()) {
if cursor.item().unwrap().status == *status {
if cursor.seek_forward(&PathTarget::Path(repo_path), Bias::Left, &()) {
if &cursor.item().unwrap().status == status {
continue;
}
}
changed_path_statuses.push(Edit::Insert(StatusEntry {
repo_path: repo_path.clone(),
status: *status,
status: status.clone(),
}));
}
@ -5257,7 +5280,7 @@ impl BackgroundScanner {
new_entries_by_path.insert_or_replace(
StatusEntry {
repo_path: repo_path.clone(),
status: *status,
status: status.clone(),
},
&(),
);
@ -5771,7 +5794,7 @@ impl<'a> GitTraversal<'a> {
} else if entry.is_file() {
// For a file entry, park the cursor on the corresponding status
if statuses.seek_forward(&PathTarget::Path(repo_path.as_ref()), Bias::Left, &()) {
self.current_entry_status = Some(statuses.item().unwrap().status);
self.current_entry_status = Some(statuses.item().unwrap().combined_status());
}
}
}
@ -6136,19 +6159,23 @@ impl<'a> TryFrom<(&'a CharBag, &PathMatcher, proto::Entry)> for Entry {
}
}
fn git_status_from_proto(git_status: Option<i32>) -> Option<GitFileStatus> {
git_status.and_then(|status| {
proto::GitStatus::from_i32(status).map(|status| match status {
// TODO pass the status pair all the way through
fn status_pair_from_proto(proto: i32) -> Option<GitStatusPair> {
let proto = proto::GitStatus::from_i32(proto)?;
let worktree_status = match proto {
proto::GitStatus::Added => GitFileStatus::Added,
proto::GitStatus::Modified => GitFileStatus::Modified,
proto::GitStatus::Conflict => GitFileStatus::Conflict,
proto::GitStatus::Deleted => GitFileStatus::Deleted,
})
};
Some(GitStatusPair {
index_status: None,
worktree_status: Some(worktree_status),
})
}
fn git_status_to_proto(status: GitFileStatus) -> i32 {
match status {
fn status_pair_to_proto(status: GitStatusPair) -> i32 {
match status.combined() {
GitFileStatus::Added => proto::GitStatus::Added as i32,
GitFileStatus::Modified => proto::GitStatus::Modified as i32,
GitFileStatus::Conflict => proto::GitStatus::Conflict as i32,

36
crates/worktree/src/worktree_tests.rs
View file

@ -2179,7 +2179,7 @@ async fn test_rename_work_directory(cx: &mut TestAppContext) {
cx.read(|cx| {
let tree = tree.read(cx);
let repo = tree.repositories().next().unwrap();
let repo = tree.repositories().iter().next().unwrap();
assert_eq!(repo.path.as_ref(), Path::new("projects/project1"));
assert_eq!(
tree.status_for_file(Path::new("projects/project1/a")),
@ -2200,7 +2200,7 @@ async fn test_rename_work_directory(cx: &mut TestAppContext) {
cx.read(|cx| {
let tree = tree.read(cx);
let repo = tree.repositories().next().unwrap();
let repo = tree.repositories().iter().next().unwrap();
assert_eq!(repo.path.as_ref(), Path::new("projects/project2"));
assert_eq!(
tree.status_for_file(Path::new("projects/project2/a")),
@ -2380,8 +2380,8 @@ async fn test_file_status(cx: &mut TestAppContext) {
// Check that the right git state is observed on startup
tree.read_with(cx, |tree, _cx| {
let snapshot = tree.snapshot();
assert_eq!(snapshot.repositories().count(), 1);
let repo_entry = snapshot.repositories().next().unwrap();
assert_eq!(snapshot.repositories().iter().count(), 1);
let repo_entry = snapshot.repositories().iter().next().unwrap();
assert_eq!(repo_entry.path.as_ref(), Path::new("project"));
assert!(repo_entry.location_in_repo.is_none());
@ -2554,16 +2554,16 @@ async fn test_git_repository_status(cx: &mut TestAppContext) {
// Check that the right git state is observed on startup
tree.read_with(cx, |tree, _cx| {
let snapshot = tree.snapshot();
let repo = snapshot.repositories().next().unwrap();
let repo = snapshot.repositories().iter().next().unwrap();
let entries = repo.status().collect::<Vec<_>>();
assert_eq!(entries.len(), 3);
assert_eq!(entries[0].repo_path.as_ref(), Path::new("a.txt"));
assert_eq!(entries[0].status, GitFileStatus::Modified);
assert_eq!(entries[0].worktree_status(), Some(GitFileStatus::Modified));
assert_eq!(entries[1].repo_path.as_ref(), Path::new("b.txt"));
assert_eq!(entries[1].status, GitFileStatus::Untracked);
assert_eq!(entries[1].worktree_status(), Some(GitFileStatus::Untracked));
assert_eq!(entries[2].repo_path.as_ref(), Path::new("d.txt"));
assert_eq!(entries[2].status, GitFileStatus::Deleted);
assert_eq!(entries[2].worktree_status(), Some(GitFileStatus::Deleted));
});
std::fs::write(work_dir.join("c.txt"), "some changes").unwrap();
@ -2576,19 +2576,19 @@ async fn test_git_repository_status(cx: &mut TestAppContext) {
tree.read_with(cx, |tree, _cx| {
let snapshot = tree.snapshot();
let repository = snapshot.repositories().next().unwrap();
let repository = snapshot.repositories().iter().next().unwrap();
let entries = repository.status().collect::<Vec<_>>();
std::assert_eq!(entries.len(), 4, "entries: {entries:?}");
assert_eq!(entries[0].repo_path.as_ref(), Path::new("a.txt"));
assert_eq!(entries[0].status, GitFileStatus::Modified);
assert_eq!(entries[0].worktree_status(), Some(GitFileStatus::Modified));
assert_eq!(entries[1].repo_path.as_ref(), Path::new("b.txt"));
assert_eq!(entries[1].status, GitFileStatus::Untracked);
assert_eq!(entries[1].worktree_status(), Some(GitFileStatus::Untracked));
// Status updated
assert_eq!(entries[2].repo_path.as_ref(), Path::new("c.txt"));
assert_eq!(entries[2].status, GitFileStatus::Modified);
assert_eq!(entries[2].worktree_status(), Some(GitFileStatus::Modified));
assert_eq!(entries[3].repo_path.as_ref(), Path::new("d.txt"));
assert_eq!(entries[3].status, GitFileStatus::Deleted);
assert_eq!(entries[3].worktree_status(), Some(GitFileStatus::Deleted));
});
git_add("a.txt", &repo);
@ -2609,7 +2609,7 @@ async fn test_git_repository_status(cx: &mut TestAppContext) {
tree.read_with(cx, |tree, _cx| {
let snapshot = tree.snapshot();
let repo = snapshot.repositories().next().unwrap();
let repo = snapshot.repositories().iter().next().unwrap();
let entries = repo.status().collect::<Vec<_>>();
// Deleting an untracked entry, b.txt, should leave no status
@ -2621,7 +2621,7 @@ async fn test_git_repository_status(cx: &mut TestAppContext) {
&entries
);
assert_eq!(entries[0].repo_path.as_ref(), Path::new("a.txt"));
assert_eq!(entries[0].status, GitFileStatus::Deleted);
assert_eq!(entries[0].worktree_status(), Some(GitFileStatus::Deleted));
});
}
@ -2676,8 +2676,8 @@ async fn test_repository_subfolder_git_status(cx: &mut TestAppContext) {
// Ensure that the git status is loaded correctly
tree.read_with(cx, |tree, _cx| {
let snapshot = tree.snapshot();
assert_eq!(snapshot.repositories().count(), 1);
let repo = snapshot.repositories().next().unwrap();
assert_eq!(snapshot.repositories().iter().count(), 1);
let repo = snapshot.repositories().iter().next().unwrap();
// Path is blank because the working directory of
// the git repository is located at the root of the project
assert_eq!(repo.path.as_ref(), Path::new(""));
@ -2707,7 +2707,7 @@ async fn test_repository_subfolder_git_status(cx: &mut TestAppContext) {
tree.read_with(cx, |tree, _cx| {
let snapshot = tree.snapshot();
assert!(snapshot.repositories().next().is_some());
assert!(snapshot.repositories().iter().next().is_some());
assert_eq!(snapshot.status_for_file("c.txt"), None);
assert_eq!(snapshot.status_for_file("d/e.txt"), None);