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

Commit All Mode (#24293)

Browse source 
- **Base diffs on uncommitted changes**
- **Show added files in project diff view**
- **Fix git panel optimism**
- **boop**
- **Co-Authored-By: Cole <cole@zed.dev>**
- **Fix commit (all) buttons state**
- **WIP**
- **WIP: commit all mode**

Closes #ISSUE

Release Notes:

- N/A
This commit is contained in:
Conrad Irwin 2025-02-05 12:13:32 -07:00 • committed by GitHub
parent 6d81ad1e0b
commit 971a91ced7
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
5 changed files with 142 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -75,15 +75,15 @@ struct SerializedGitPanel {
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
enum Section {
Changed,
Created,
Tracked,
New,
}
impl Section {
pub fn contains(&self, status: FileStatus) -> bool {
match self {
Section::Changed => !status.is_created(),
Section::Created => status.is_created(),
Section::Tracked => !status.is_created(),
Section::New => status.is_created(),
}
}
}
@ -99,8 +99,8 @@ impl GitHeaderEntry {
}
pub fn title(&self) -> &'static str {
match self.header {
Section::Changed => "Changed",
Section::Created => "New",
Section::Tracked => "Changed",
Section::New => "New",
}
}
}
@ -112,9 +112,9 @@ enum GitListEntry {
}
impl GitListEntry {
fn status_entry(&self) -> Option<GitStatusEntry> {
fn status_entry(&self) -> Option<&GitStatusEntry> {
match self {
GitListEntry::GitStatusEntry(entry) => Some(entry.clone()),
GitListEntry::GitStatusEntry(entry) => Some(entry),
_ => None,
}
}
@ -129,7 +129,7 @@ pub struct GitStatusEntry {
pub(crate) is_staged: Option<bool>,
}
pub struct PendingOperation {
struct PendingOperation {
finished: bool,
will_become_staged: bool,
repo_paths: HashSet<RepoPath>,
@ -158,8 +158,11 @@ pub struct GitPanel {
pending: Vec<PendingOperation>,
commit_task: Task<Result<()>>,
commit_pending: bool,
can_commit: bool,
can_commit_all: bool,
tracked_staged_count: usize,
tracked_count: usize,
new_staged_count: usize,
new_count: usize,
}
fn commit_message_editor(
@ -272,8 +275,10 @@ impl GitPanel {
commit_editor,
project,
workspace,
can_commit: false,
can_commit_all: false,
tracked_staged_count: 0,
tracked_count: 0,
new_staged_count: 0,
new_count: 0,
};
git_panel.schedule_update(false, window, cx);
git_panel.show_scrollbar = git_panel.should_show_scrollbar(cx);
@ -579,7 +584,7 @@ impl GitPanel {
section.contains(&status_entry)
&& status_entry.is_staged != Some(goal_staged_state)
})
.map(|status_entry| status_entry.repo_path)
.map(|status_entry| status_entry.repo_path.clone())
.collect::<Vec<_>>();
(goal_staged_state, entries)
@ -593,10 +598,12 @@ impl GitPanel {
repo_paths: repo_paths.iter().cloned().collect(),
finished: false,
});
let repo_paths = repo_paths.clone();
let active_repository = active_repository.clone();
self.update_counts();
cx.notify();
cx.spawn({
let repo_paths = repo_paths.clone();
let active_repository = active_repository.clone();
|this, mut cx| async move {
let result = cx
.update(|cx| {
@ -673,7 +680,8 @@ impl GitPanel {
let Some(active_repository) = self.active_repository.clone() else {
return;
};
if !self.can_commit {
if !self.has_staged_changes() {
self.commit_tracked_changes(&Default::default(), name_and_email, window, cx);
return;
}
let message = self.commit_editor.read(cx).text(cx);
@ -716,7 +724,7 @@ impl GitPanel {
let Some(active_repository) = self.active_repository.clone() else {
return;
};
if !self.can_commit_all {
if !self.has_staged_changes() || !self.has_tracked_changes() {
return;
}
@ -731,10 +739,10 @@ impl GitPanel {
.iter()
.filter_map(|entry| entry.status_entry())
.filter(|status_entry| {
Section::Changed.contains(status_entry.status)
Section::Tracked.contains(status_entry.status)
&& !status_entry.is_staged.unwrap_or(false)
})
.map(|status_entry| status_entry.repo_path)
.map(|status_entry| status_entry.repo_path.clone())
.collect::<Vec<_>>();
self.commit_task = cx.spawn_in(window, |git_panel, mut cx| async move {
@ -911,10 +919,6 @@ impl GitPanel {
let repo = repo.read(cx);
let path_set = HashSet::from_iter(repo.status().map(|entry| entry.repo_path));
let mut has_changed_checked_boxes = false;
let mut has_changed = false;
let mut has_added_checked_boxes = false;
// Second pass - create entries with proper depth calculation
for entry in repo.status() {
let (depth, difference) =
@ -951,15 +955,8 @@ impl GitPanel {
};
if is_new {
if entry.is_staged != Some(false) {
has_added_checked_boxes = true
}
new_entries.push(entry);
} else {
has_changed = true;
if entry.is_staged != Some(false) {
has_changed_checked_boxes = true
}
changed_entries.push(entry);
}
}
@ -970,7 +967,7 @@ impl GitPanel {
if changed_entries.len() > 0 {
self.entries.push(GitListEntry::Header(GitHeaderEntry {
header: Section::Changed,
header: Section::Tracked,
}));
self.entries.extend(
changed_entries
@ -980,7 +977,7 @@ impl GitPanel {
}
if new_entries.len() > 0 {
self.entries.push(GitListEntry::Header(GitHeaderEntry {
header: Section::Created,
header: Section::New,
}));
self.entries
.extend(new_entries.into_iter().map(GitListEntry::GitStatusEntry));
@ -988,39 +985,62 @@ impl GitPanel {
for (ix, entry) in self.entries.iter().enumerate() {
if let Some(status_entry) = entry.status_entry() {
self.entries_by_path.insert(status_entry.repo_path, ix);
self.entries_by_path
.insert(status_entry.repo_path.clone(), ix);
}
}
self.can_commit = has_changed_checked_boxes || has_added_checked_boxes;
self.can_commit_all = has_changed || has_added_checked_boxes;
self.update_counts();
self.select_first_entry_if_none(cx);
cx.notify();
}
fn header_state(&self, header_type: Section) -> ToggleState {
let mut count = 0;
let mut staged_count = 0;
'outer: for entry in &self.entries {
let Some(entry) = entry.status_entry() else {
fn update_counts(&mut self) {
self.new_count = 0;
self.tracked_count = 0;
self.new_staged_count = 0;
self.tracked_staged_count = 0;
for entry in &self.entries {
let Some(status_entry) = entry.status_entry() else {
continue;
};
if entry.status.is_created() != (header_type == Section::Created) {
continue;
}
count += 1;
for pending in self.pending.iter().rev() {
if pending.repo_paths.contains(&entry.repo_path) {
if pending.will_become_staged {
staged_count += 1;
}
continue 'outer;
if status_entry.status.is_created() {
self.new_count += 1;
if self.entry_appears_staged(status_entry) != Some(false) {
self.new_staged_count += 1;
}
} else {
self.tracked_count += 1;
if self.entry_appears_staged(status_entry) != Some(false) {
self.tracked_staged_count += 1;
}
}
staged_count += entry.status.is_staged().unwrap_or(false) as usize;
}
}
fn entry_appears_staged(&self, entry: &GitStatusEntry) -> Option<bool> {
for pending in self.pending.iter().rev() {
if pending.repo_paths.contains(&entry.repo_path) {
return Some(pending.will_become_staged);
}
}
entry.is_staged
}
fn has_staged_changes(&self) -> bool {
self.tracked_staged_count > 0 || self.new_staged_count > 0
}
fn has_tracked_changes(&self) -> bool {
self.tracked_count > 0
}
fn header_state(&self, header_type: Section) -> ToggleState {
let (staged_count, count) = match header_type {
Section::New => (self.new_staged_count, self.new_count),
Section::Tracked => (self.tracked_staged_count, self.tracked_count),
};
if staged_count == 0 {
ToggleState::Unselected
} else if count == staged_count {
@ -1157,25 +1177,27 @@ impl GitPanel {
cx: &Context<Self>,
) -> impl IntoElement {
let editor = self.commit_editor.clone();
let can_commit = !self.commit_pending && self.can_commit && !editor.read(cx).is_empty(cx);
let can_commit_all =
!self.commit_pending && self.can_commit_all && !editor.read(cx).is_empty(cx);
let can_commit =
(self.has_staged_changes() || self.has_tracked_changes()) && !self.commit_pending;
let editor_focus_handle = editor.read(cx).focus_handle(cx).clone();
let focus_handle_1 = self.focus_handle(cx).clone();
let focus_handle_2 = self.focus_handle(cx).clone();
let tooltip = if self.has_staged_changes() {
"Commit staged changes"
} else {
"Commit changes to tracked files"
};
let title = if self.has_staged_changes() {
"Commit"
} else {
"Commit All"
};
let commit_staged_button = self
.panel_button("commit-staged-changes", "Commit")
let commit_button = self
.panel_button("commit-changes", title)
.tooltip(move |window, cx| {
let focus_handle = focus_handle_1.clone();
Tooltip::for_action_in(
"Commit all staged changes",
&CommitChanges,
&focus_handle,
window,
cx,
)
Tooltip::for_action_in(tooltip, &CommitChanges, &focus_handle, window, cx)
})
.disabled(!can_commit)
.on_click({
@ -1185,31 +1207,6 @@ impl GitPanel {
})
});
let commit_all_button = self
.panel_button("commit-all-changes", "Commit All")
.tooltip(move |window, cx| {
let focus_handle = focus_handle_2.clone();
Tooltip::for_action_in(
"Commit all changes, including unstaged changes",
&CommitAllChanges,
&focus_handle,
window,
cx,
)
})
.disabled(!can_commit_all)
.on_click({
let name_and_email = name_and_email.clone();
cx.listener(move |this, _: &ClickEvent, window, cx| {
this.commit_tracked_changes(
&CommitAllChanges,
name_and_email.clone(),
window,
cx,
)
})
});
div().w_full().h(px(140.)).px_2().pt_1().pb_2().child(
v_flex()
.id("commit-editor-container")
@ -1229,8 +1226,7 @@ impl GitPanel {
.right_3()
.gap_1p5()
.child(div().gap_1().flex_grow())
.child(commit_all_button)
.child(commit_staged_button),
.child(commit_button),
),
)
}
@ -1423,8 +1419,17 @@ impl GitPanel {
_window: &Window,
cx: &Context<Self>,
) -> AnyElement {
let checkbox = Checkbox::new(header.title(), self.header_state(header.header))
let header_state = if self.has_staged_changes() {
self.header_state(header.header)
} else {
match header.header {
Section::Tracked => ToggleState::Selected,
Section::New => ToggleState::Unselected,
}
};
let checkbox = Checkbox::new(header.title(), header_state)
.disabled(!has_write_access)
.placeholder(!self.has_staged_changes())
.fill()
.elevation(ElevationIndex::Surface);
let selected = self.selected_entry == Some(ix);
@ -1507,14 +1512,19 @@ impl GitPanel {
let id: ElementId = ElementId::Name(format!("entry_{}", display_name).into());
let is_staged = pending
let mut is_staged = pending
.or_else(|| entry.is_staged)
.map(ToggleState::from)
.unwrap_or(ToggleState::Indeterminate);
if !self.has_staged_changes() && !entry.status.is_created() {
is_staged = ToggleState::Selected;
}
let checkbox = Checkbox::new(id, is_staged)
.disabled(!has_write_access)
.fill()
.placeholder(!self.has_staged_changes())
.elevation(ElevationIndex::Surface)
.on_click({
let entry = entry.clone();
@ -1532,6 +1542,7 @@ impl GitPanel {
.id(("start-slot", ix))
.gap(DynamicSpacing::Base04.rems(cx))
.child(checkbox)
.tooltip(|window, cx| Tooltip::for_action("Stage File", &ToggleStaged, window, cx))
.child(git_status_icon(status, cx))
.on_mouse_down(MouseButton::Left, |_, _, cx| {
// prevent the list item active state triggering when toggling checkbox