Compute branch diff statuses from worktree contents

Replace the status-combination table with a real merge-base-to-worktree tree diff, make GitStore share one DiffBufferList per repository with the branch diff view, keep repo_snapshots as index/worktree truth with separate display status APIs, and make non-HEAD gutter hunks read-only. The git.diff_base setting values are now "head" and "default_branch", applied live and toggleable from the editor controls menu. git::Diff follows the setting; git::DiffHead always opens the HEAD diff; and git::BranchDiff is renamed to git::DiffBranch with a deprecated alias.

Ben Kunkle committed 3 months ago

Commit ecb8e7e1 parent b10f68333 files · +1552 −1324Browse files

Showing the changes to crates/buffer_diff/src/buffer_diff.rs (1 of 33 files). Show all

Unified · Split

crates/buffer_diff/src/buffer_diff.rs+40−4

     diff_snapshot: Option<BufferDiffSnapshot>,
     secondary_diff: Option<Entity<BufferDiff>>,
     buffer_snapshot: text::BufferSnapshot,
+    base_kind: DiffBaseKind,
+}
+/// Where this diff's base text came from. Only diffs whose base is HEAD
+/// support staging and restoring hunks; a diff against any other base (e.g.
+/// the merge base with another branch) would rewrite committed work.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DiffBaseKind {
+    /// The buffer's committed (HEAD) content.
+    Head,
+    /// The buffer's index (staged) content.
+    Index,
+    /// An arbitrary blob, such as the merge base with another branch.
+    Oid,
+    /// Arbitrary caller-provided text, such as an agent's original text,
+    /// the clipboard, or another file.
+    Custom,
 }
 #[derive(Clone)]
         buffer: &text::BufferSnapshot,
         language: Option<Arc<Language>>,
         language_registry: Option<Arc<LanguageRegistry>>,
+        base_kind: DiffBaseKind,
         cx: &mut App,
     ) -> Self {
         let base_text = cx.new(|cx| {
             diff_snapshot: None,
             buffer_snapshot: buffer.clone(),
             secondary_diff: None,
+            base_kind,
         }
     }
     pub fn new_with_base_text_buffer(
         buffer: &text::BufferSnapshot,
         base_text_buffer: Entity<language::Buffer>,
+        base_kind: DiffBaseKind,
         _cx: &mut App,
     ) -> Self {
         BufferDiff {
             diff_snapshot: None,
             buffer_snapshot: buffer.clone(),
             secondary_diff: None,
+            base_kind,
         }
     }
         buffer: &text::BufferSnapshot,
         language: Option<Arc<Language>>,
         language_registry: Option<Arc<LanguageRegistry>>,
+        base_kind: DiffBaseKind,
         cx: &mut Context<Self>,
     ) -> Self {
         let base_text = buffer.text();
             diff_snapshot: Some(diff_snapshot),
             buffer_snapshot: buffer.clone(),
             secondary_diff: None,
+            base_kind,
         }
     }
         buffer: &text::BufferSnapshot,
         cx: &mut Context<Self>,
     ) -> Self {
-        let mut this = BufferDiff::new(buffer, None, None, cx);
+        let mut this = BufferDiff::new(buffer, None, None, DiffBaseKind::Head, cx);
         let mut base_text = base_text.to_owned();
         text::LineEnding::normalize(&mut base_text);
         let base_text_buffer = cx.new(|cx| {
         self.secondary_diff = Some(diff);
     }
+    pub fn base_kind(&self) -> DiffBaseKind {
+        self.base_kind
+    }
+    /// Whether hunks in this diff can be staged or restored: true only when
+    /// the diff's base is HEAD.
+    pub fn is_stageable(&self) -> bool {
+        self.base_kind == DiffBaseKind::Head
+    }
     pub fn secondary_diff(&self) -> Option<Entity<BufferDiff>> {
         self.secondary_diff.clone()
     }
             ],
         );
-        diff = cx.update(|cx| BufferDiff::new(&buffer, None, None, cx).snapshot(cx));
+        diff = cx
+            .update(|cx| BufferDiff::new(&buffer, None, None, DiffBaseKind::Head, cx).snapshot(cx));
         assert_hunks::<&str, _>(
             diff.hunks_intersecting_range(
                 Anchor::min_max_range_for_buffer(buffer.remote_id()),
         let mut buffer = Buffer::new(ReplicaId::LOCAL, BufferId::new(1).unwrap(), buffer_text_1);
-        let empty_diff = cx.update(|cx| BufferDiff::new(&buffer, None, None, cx).snapshot(cx));
+        let empty_diff = cx
+            .update(|cx| BufferDiff::new(&buffer, None, None, DiffBaseKind::Head, cx).snapshot(cx));
         let diff_1 = BufferDiffSnapshot::new_sync(&buffer, base_text.clone(), cx);
         let DiffChanged {
             changed_range,
         );
         let buffer_snapshot = buffer.snapshot();
-        let diff = cx.new(|cx| BufferDiff::new(&buffer_snapshot, None, None, cx));
+        let diff =
+            cx.new(|cx| BufferDiff::new(&buffer_snapshot, None, None, DiffBaseKind::Head, cx));
         diff.update(cx, |diff, cx| {
             diff.set_base_text(Some(Arc::from(base_text_crlf)), buffer_snapshot.clone(), cx)
         })