feat: provide a way to record and apply index changes.

Byron · Byron · commit 7a0820d069d2 · 2024-11-19T11:42:32.000+01:00
These changes will then be applicable to an index that is created
from the written tree editor.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/gix-merge/Cargo.toml b/gix-merge/Cargo.toml
@@ -32,6 +32,7 @@ gix-quote = { version = "^0.4.13", path = "../gix-quote" }
 gix-revision = { version = "^0.30.0", path = "../gix-revision", default-features = false, features = ["merge_base"] }
 gix-revwalk = { version = "^0.16.0", path = "../gix-revwalk" }
 gix-diff = { version = "^0.47.0", path = "../gix-diff", default-features = false, features = ["blob"] }
+gix-index = { version = "^0.36.0", path = "../gix-index" }
 
 thiserror = "2.0.0"
 imara-diff = { version = "0.1.7" }
diff --git a/gix-merge/src/tree/mod.rs b/gix-merge/src/tree/mod.rs
@@ -81,6 +81,21 @@ impl Outcome<'_> {
     pub fn has_unresolved_conflicts(&self, how: TreatAsUnresolved) -> bool {
         self.conflicts.iter().any(|c| c.is_unresolved(how))
     }
+
+    /// Returns `true` if `index` changed as we applied conflicting stages to it, using `how` to determine if a
+    /// conflict should be considered unresolved.
+    /// It's important that `index` is at the state of [`Self::tree`].
+    ///
+    /// Note that in practice, whenever there is a single [conflict], this function will return `true`.
+    /// Also, the unconflicted stage of such entries will be removed merely by setting a flag, so the
+    /// in-memory entry is still present.
+    pub fn index_changed_after_applying_conflicts(
+        &self,
+        index: &mut gix_index::State,
+        how: TreatAsUnresolved,
+    ) -> Result<bool, apply_index_entries::Error> {
+        apply_index_entries(&self.conflicts, how, index)
+    }
 }
 
 /// A description of a conflict (i.e. merge issue without an auto-resolution) as seen during a [tree-merge](crate::tree()).
@@ -99,11 +114,30 @@ pub struct Conflict {
     pub ours: Change,
     /// The change representing *their* side.
     pub theirs: Change,
+    /// An array to store an entry for each stage of the conflict.
+    ///
+    /// * `entries[0]`  => Base
+    /// * `entries[1]`  => Ours
+    /// * `entries[2]`  => Theirs
+    ///
+    /// Note that ours and theirs might be swapped, so one should access it through [`Self::entries()`] to compensate for that.
+    pub entries: [Option<ConflictIndexEntry>; 3],
     /// Determine how to interpret the `ours` and `theirs` fields. This is used to implement [`Self::changes_in_resolution()`]
     /// and [`Self::into_parts_by_resolution()`].
     map: ConflictMapping,
 }
 
+/// A conflicting entry for insertion into the index.
+/// It will always be either on stage 1 (ancestor/base), 2 (ours) or 3 (theirs)
+#[derive(Debug, Clone, Copy)]
+pub struct ConflictIndexEntry {
+    /// The kind of object at this stage.
+    /// Note that it's possible that this is a directory, for instance if a directory was replaced with a file.
+    pub mode: gix_object::tree::EntryMode,
+    /// The id defining the state of the object.
+    pub id: gix_hash::ObjectId,
+}
+
 /// A utility to help define which side is what in the [`Conflict`] type.
 #[derive(Debug, Clone, Copy)]
 enum ConflictMapping {
@@ -178,6 +212,14 @@ impl Conflict {
         }
     }
 
+    /// Return the index entries for insertion into the index, to match with what's returned by [`Self::changes_in_resolution()`].
+    pub fn entries(&self) -> [Option<ConflictIndexEntry>; 3] {
+        match self.map {
+            ConflictMapping::Original => self.entries,
+            ConflictMapping::Swapped => [self.entries[0], self.entries[2], self.entries[1]],
+        }
+    }
+
     /// Return information about the content merge if it was performed.
     pub fn content_merge(&self) -> Option<ContentMerge> {
         match &self.resolution {
@@ -308,3 +350,96 @@ pub struct Options {
 
 pub(super) mod function;
 mod utils;
+pub mod apply_index_entries {
+
+    pub(super) mod function {
+        use crate::tree::{Conflict, Resolution, ResolutionFailure, TreatAsUnresolved};
+        use bstr::{BString, ByteSlice};
+
+        /// The error returned by [`apply_index_entries()`].
+        #[derive(Debug, thiserror::Error)]
+        #[allow(missing_docs)]
+        pub enum Error {
+            #[error(
+                "Could not find '{path}' in the index, even though it should have the non-conflicting variant of it."
+            )]
+            MissingPathInIndex { path: BString },
+        }
+
+        /// Returns `true` if `index` changed as we applied conflicting stages to it, using `how` to determine if a
+        /// conflict should be considered unresolved.
+        /// Once a stage of a path conflicts, the unconflicting stage is removed even though it might be the one
+        /// that is currently checked out.
+        /// This removal, however, is only done by flagging it with [gix_index::entry::Flags::REMOVE], which means
+        /// these entries won't be written back to disk but will still be present in the index.
+        /// It's important that `index` matches the tree that was produced as part of the merge that also
+        /// brought about `conflicts`, or else this function will fail if it cannot find the path matching
+        /// the conflicting entries.
+        ///
+        /// Note that in practice, whenever there is a single [conflict], this function will return `true`.
+        /// Errors can only occour if `index` isn't the one created from the merged tree that produced the `conflicts`.
+        pub fn apply_index_entries(
+            conflicts: &[Conflict],
+            how: TreatAsUnresolved,
+            index: &mut gix_index::State,
+        ) -> Result<bool, Error> {
+            let len = index.entries().len();
+            for conflict in conflicts.iter().filter(|c| c.is_unresolved(how)) {
+                let path = match &conflict.resolution {
+                    Ok(success) => match success {
+                        Resolution::SourceLocationAffectedByRename { final_location } => Some(final_location),
+                        Resolution::OursModifiedTheirsRenamedAndChangedThenRename { final_location, .. } => {
+                            final_location.as_ref()
+                        }
+                        Resolution::OursModifiedTheirsModifiedThenBlobContentMerge { .. } => None,
+                    },
+                    Err(failure) => match failure {
+                        ResolutionFailure::OursRenamedTheirsRenamedDifferently { .. }
+                        | ResolutionFailure::OursModifiedTheirsRenamedTypeMismatch
+                        | ResolutionFailure::OursDeletedTheirsRenamed
+                        | ResolutionFailure::OursModifiedTheirsDeleted
+                        | ResolutionFailure::Unknown => None,
+                        ResolutionFailure::OursModifiedTheirsDirectoryThenOursRenamed {
+                            renamed_unique_path_to_modified_blob,
+                        } => Some(renamed_unique_path_to_modified_blob),
+                        ResolutionFailure::OursAddedTheirsAddedTypeMismatch { their_unique_location } => {
+                            Some(their_unique_location)
+                        }
+                    },
+                };
+                let path = path.map_or_else(|| conflict.ours.location(), |path| path.as_bstr());
+                if conflict.entries.iter().any(|e| e.is_some()) {
+                    let existing_entry = {
+                        let pos = index
+                            .entry_index_by_path_and_stage_bounded(path, gix_index::entry::Stage::Unconflicted, len)
+                            .ok_or_else(|| Error::MissingPathInIndex { path: path.to_owned() })?;
+                        &mut index.entries_mut()[pos]
+                    };
+                    existing_entry.flags.insert(gix_index::entry::Flags::REMOVE);
+                }
+
+                let entries_with_stage = conflict.entries().into_iter().enumerate().filter_map(|(idx, entry)| {
+                    entry.map(|e| {
+                        (
+                            match idx {
+                                0 => gix_index::entry::Stage::Base,
+                                1 => gix_index::entry::Stage::Ours,
+                                2 => gix_index::entry::Stage::Theirs,
+                                _ => unreachable!("fixed size arra with three items"),
+                            },
+                            e,
+                        )
+                    })
+                });
+                for (stage, entry) in entries_with_stage {
+                    index.dangerously_push_entry(Default::default(), entry.id, stage.into(), entry.mode.into(), path);
+                }
+            }
+
+            index.sort_entries();
+            Ok(index.entries().len() != len)
+        }
+    }
+    pub use function::Error;
+}
+pub use apply_index_entries::function::apply_index_entries;
diff --git a/gix-merge/src/tree/utils.rs b/gix-merge/src/tree/utils.rs
@@ -563,6 +563,7 @@ impl Conflict {
             resolution,
             ours: ours.clone(),
             theirs: theirs.clone(),
+            entries: Default::default(),
             map: match outer_map {
                 ConflictMapping::Original => map,
                 ConflictMapping::Swapped => map.swapped(),
diff --git a/gix-merge/tests/fixtures/generated-archives/tree-baseline.tar b/gix-merge/tests/fixtures/generated-archives/tree-baseline.tar
diff --git a/gix-merge/tests/merge/tree/baseline.rs b/gix-merge/tests/merge/tree/baseline.rs
@@ -6,7 +6,7 @@ use gix_object::FindExt;
 use std::path::{Path, PathBuf};
 
 /// An entry in the conflict
-#[derive(Debug)]
+#[derive(Debug, Eq, PartialEq)]
 pub struct Entry {
     /// The relative path in the repository
     pub location: String,
@@ -17,7 +17,7 @@ pub struct Entry {
 }
 
 /// Keep track of all the sides of a conflict. Some might not be set to indicate removal, including the ancestor.
-#[derive(Default, Debug)]
+#[derive(Default, Debug, Eq, PartialEq)]
 pub struct Conflict {
     pub ancestor: Option<Entry>,
     pub ours: Option<Entry>,
@@ -129,7 +129,7 @@ impl Iterator for Expectations<'_> {
         let mut tokens = line.split(' ');
         let (
             Some(subdir),
-            Some(conflict_style),
+            Some(conflict_style_name),
             Some(our_commit_id),
             Some(our_side_name),
             Some(their_commit_id),
@@ -160,7 +160,7 @@ impl Iterator for Expectations<'_> {
         });
 
         let subdir_path = self.root.join(subdir);
-        let conflict_style = match conflict_style {
+        let conflict_style = match conflict_style_name {
             "merge" => ConflictStyle::Merge,
             "diff3" => ConflictStyle::Diff3,
             unknown => unreachable!("Unknown conflict style: '{unknown}'"),
@@ -221,6 +221,10 @@ fn parse_merge_info(content: String) -> MergeInfo {
         *field = Some(entry);
     }
 
+    if conflict.any_location().is_some() && conflicts.last() != Some(&conflict) {
+        conflicts.push(conflict);
+    }
+
     while lines.peek().is_some() {
         out.information
             .push(parse_info(&mut lines).expect("if there are lines, it should be valid info"));
@@ -285,6 +289,30 @@ fn parse_info<'a>(mut lines: impl Iterator<Item = &'a str>) -> Option<ConflictIn
     Some(ConflictInfo { paths, kind, message })
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub struct DebugIndexEntry<'a> {
+    path: &'a BStr,
+    id: gix_hash::ObjectId,
+    mode: gix_index::entry::Mode,
+    stage: gix_index::entry::Stage,
+}
+
+pub fn clear_entries(state: &gix_index::State) -> Vec<DebugIndexEntry<'_>> {
+    state
+        .entries()
+        .iter()
+        .map(|entry| {
+            let path = entry.path(state);
+            DebugIndexEntry {
+                path,
+                id: entry.id,
+                mode: entry.mode,
+                stage: entry.stage(),
+            }
+        })
+        .collect()
+}
+
 pub fn visualize_tree(
     id: &gix_hash::oid,
     odb: &impl gix_object::Find,
@@ -342,3 +370,35 @@ pub fn show_diff_and_fail(
         expected.information
     );
 }
+
+pub(crate) fn apply_git_index_entries(conflicts: Vec<Conflict>, state: &mut gix_index::State) {
+    let len = state.entries().len();
+    for Conflict { ours, theirs, ancestor } in conflicts {
+        for (entry, stage) in [
+            ancestor.map(|e| (e, gix_index::entry::Stage::Base)),
+            ours.map(|e| (e, gix_index::entry::Stage::Ours)),
+            theirs.map(|e| (e, gix_index::entry::Stage::Theirs)),
+        ]
+        .into_iter()
+        .filter_map(std::convert::identity)
+        {
+            if let Some(pos) = state.entry_index_by_path_and_stage_bounded(
+                entry.location.as_str().into(),
+                gix_index::entry::Stage::Unconflicted,
+                len,
+            ) {
+                state.entries_mut()[pos].flags.insert(gix_index::entry::Flags::REMOVE)
+            }
+
+            state.dangerously_push_entry(
+                Default::default(),
+                entry.id,
+                stage.into(),
+                entry.mode.into(),
+                entry.location.as_str().into(),
+            );
+        }
+    }
+    state.sort_entries();
+    state.remove_entries(|_, _, e| e.flags.contains(gix_index::entry::Flags::REMOVE));
+}
diff --git a/gix-merge/tests/merge/tree/mod.rs b/gix-merge/tests/merge/tree/mod.rs
@@ -1,6 +1,7 @@
 use crate::tree::baseline::Deviation;
 use gix_diff::Rewrites;
 use gix_merge::commit::Options;
+use gix_merge::tree::TreatAsUnresolved;
 use gix_object::Write;
 use gix_worktree::stack::state::attributes;
 use std::path::Path;
@@ -98,6 +99,30 @@ fn run_baseline() -> crate::Result {
                 );
             }
         }
+
+        let mut actual_index = gix_index::State::from_tree(&actual_id, &odb, Default::default())?;
+        let expected_index = {
+            dbg!(&actual.conflicts, &merge_info.conflicts);
+            let mut index = actual_index.clone();
+            if let Some(conflicts) = merge_info.conflicts {
+                baseline::apply_git_index_entries(conflicts, &mut index)
+            }
+            index
+        };
+        let conflicts_like_in_git = TreatAsUnresolved::Renames;
+        let did_change = actual.index_changed_after_applying_conflicts(&mut actual_index, conflicts_like_in_git)?;
+        actual_index.remove_entries(|_, _, e| e.flags.contains(gix_index::entry::Flags::REMOVE));
+
+        pretty_assertions::assert_eq!(
+            baseline::clear_entries(&actual_index),
+            baseline::clear_entries(&expected_index),
+            "{case_name}: index mismatch"
+        );
+        assert_eq!(
+            did_change,
+            actual.has_unresolved_conflicts(conflicts_like_in_git),
+            "{case_name}: If there is any kind of conflict, the index should have been changed"
+        );
     }
 
     assert_eq!(
