adapt to changes in gix-index

Author: Byron

gitoxide-core/src/index/information.rs

@@ -6,6 +6,7 @@ pub struct Options {
 
 #[cfg(feature = "serde")]
 mod serde_only {
+    use gix::index::entry::Stage;
 
     mod ext {
         #[derive(serde::Serialize)]
@@ -115,11 +116,10 @@ mod serde_only {
                     let (mut intent_to_add, mut skip_worktree) = (0, 0);
                     for entry in f.entries() {
                         match entry.flags.stage() {
-                            0 => stage_0_merged += 1,
-                            1 => stage_1_base += 1,
-                            2 => stage_2_ours += 1,
-                            3 => stage_3_theirs += 1,
-                            invalid => anyhow::bail!("Invalid stage {} encountered", invalid),
+                            Stage::Unconflicted => stage_0_merged += 1,
+                            Stage::Base => stage_1_base += 1,
+                            Stage::Ours => stage_2_ours += 1,
+                            Stage::Theirs => stage_3_theirs += 1,
                         }
                         match entry.mode {
                             gix::index::entry::Mode::DIR => dir += 1,

gitoxide-core/src/repository/index/entries.rs

@@ -23,6 +23,7 @@ pub(crate) mod function {
         io::{BufWriter, Write},
     };
 
+    use gix::index::entry::Stage;
     use gix::{
         bstr::{BStr, BString},
         worktree::IndexPersistedOrInMemory,
@@ -392,11 +393,10 @@ pub(crate) mod function {
             out,
             "{} {}{:?} {} {}{}{}",
             match entry.flags.stage() {
-                0 => "       ",
-                1 => "BASE   ",
-                2 => "OURS   ",
-                3 => "THEIRS ",
-                _ => "UNKNOWN",
+                Stage::Unconflicted => "       ",
+                Stage::Base => "BASE   ",
+                Stage::Ours => "OURS   ",
+                Stage::Theirs => "THEIRS ",
             },
             if entry.flags.is_empty() {
                 "".to_string()

gix-index/tests/index/access.rs

@@ -152,7 +152,7 @@ fn entry_by_path_and_stage() {
 #[test]
 fn entry_by_path_with_conflicting_file() {
     let file = Fixture::Loose("conflicting-file").open();
-    for expected_stage in [Stage::Base,Stage::Ours, Stage::Theirs] {
+    for expected_stage in [Stage::Base, Stage::Ours, Stage::Theirs] {
         assert!(
             file.entry_by_path_and_stage("file".into(), expected_stage).is_some(),
             "we have no stage 0 during a conflict, but all other ones. Missed {expected_stage:?}"

gix-status/src/index_as_worktree/function.rs

@@ -157,11 +157,11 @@ where
             let mut idx = 0;
             while let Some(entry) = chunk_entries.get(idx) {
                 let absolute_entry_index = entry_offset + idx;
-                if idx == 0 && entry.stage() != 0 {
+                if idx == 0 && entry.stage_raw() != 0 {
                     let offset = entry_offset.checked_sub(1).and_then(|prev_idx| {
                         let prev_entry = &all_entries[prev_idx];
                         let entry_path = entry.path_in(state.path_backing);
-                        if prev_entry.stage() == 0 || prev_entry.path_in(state.path_backing) != entry_path {
+                        if prev_entry.stage_raw() == 0 || prev_entry.path_in(state.path_backing) != entry_path {
                             // prev_entry (in previous chunk) does not belong to our conflict
                             return None;
                         }
@@ -286,7 +286,7 @@ impl<'index> State<'_, 'index> {
             self.skipped_by_pathspec.fetch_add(1, Ordering::Relaxed);
             return None;
         }
-        let status = if entry.stage() != 0 {
+        let status = if entry.stage_raw() != 0 {
             Ok(
                 Conflict::try_from_entry(entries, self.path_backing, entry_index, path).map(|(conflict, offset)| {
                     *outer_entry_index += offset; // let out loop skip over entries related to the conflict
@@ -604,7 +604,7 @@ impl Conflict {
         let mut count = 0_usize;
         for stage in (start_index..(start_index + 3).min(entries.len())).filter_map(|idx| {
             let entry = &entries[idx];
-            let stage = entry.stage();
+            let stage = entry.stage_raw();
             (stage > 0 && entry.path_in(path_backing) == entry_path).then_some(stage)
         }) {
             // This could be `1 << (stage - 1)` but let's be specific.

gix-worktree/src/stack/state/mod.rs

@@ -131,7 +131,7 @@ impl State {
 
                 // Stage 0 means there is no merge going on, stage 2 means it's 'our' side of the merge, but then
                 // there won't be a stage 0.
-                if entry.mode == gix_index::entry::Mode::FILE && (entry.stage() == 0 || entry.stage() == 2) {
+                if entry.mode == gix_index::entry::Mode::FILE && (entry.stage_raw() == 0 || entry.stage_raw() == 2) {
                     let basename = path.rfind_byte(b'/').map_or(path, |pos| path[pos + 1..].as_bstr());
                     let ignore_source = names.iter().find_map(|t| {
                         match case {

gix/src/revision/spec/parse/delegate/navigate.rs

@@ -1,6 +1,7 @@
 use std::collections::HashSet;
 
 use gix_hash::ObjectId;
+use gix_index::entry::Stage;
 use gix_revision::spec::parse::{
     delegate,
     delegate::{PeelTo, Traversal},
@@ -305,9 +306,18 @@ impl<'repo> delegate::Navigate for Delegate<'repo> {
     }
 
     fn index_lookup(&mut self, path: &BStr, stage: u8) -> Option<()> {
+        let stage = match stage {
+            0 => Stage::Unconflicted,
+            1 => Stage::Base,
+            2 => Stage::Ours,
+            3 => Stage::Theirs,
+            _ => unreachable!(
+                "BUG: driver will not pass invalid stages (and it uses integer to avoid gix-index as dependency)"
+            ),
+        };
         self.unset_disambiguate_call();
         match self.repo.index() {
-            Ok(index) => match index.entry_by_path_and_stage(path, stage.into()) {
+            Ok(index) => match index.entry_by_path_and_stage(path, stage) {
                 Some(entry) => {
                     self.objs[self.idx]
                         .get_or_insert_with(HashSet::default)
@@ -323,21 +333,17 @@ impl<'repo> delegate::Navigate for Delegate<'repo> {
                     Some(())
                 }
                 None => {
-                    let stage_hint = [0, 1, 2]
+                    let stage_hint = [Stage::Unconflicted, Stage::Base, Stage::Ours]
                         .iter()
                         .filter(|our_stage| **our_stage != stage)
-                        .find_map(|stage| {
-                            index
-                                .entry_index_by_path_and_stage(path, (*stage).into())
-                                .map(|_| (*stage).into())
-                        });
+                        .find_map(|stage| index.entry_index_by_path_and_stage(path, *stage).map(|_| *stage));
                     let exists = self
                         .repo
                         .work_dir()
                         .map_or(false, |root| root.join(gix_path::from_bstr(path)).exists());
                     self.err.push(Error::IndexLookup {
                         desired_path: path.into(),
-                        desired_stage: stage.into(),
+                        desired_stage: stage,
                         exists,
                         stage_hint,
                     });

gix/src/revision/spec/parse/types.rs

@@ -98,7 +98,7 @@ pub enum Error {
         desired: usize,
         available: usize,
     },
-    #[error("Path {desired_path:?} did not exist in index at stage {desired_stage}{}{}", stage_hint.map(|actual|format!(". It does exist at stage {actual}")).unwrap_or_default(), exists.then(|| ". It exists on disk").unwrap_or(". It does not exist on disk"))]
+    #[error("Path {desired_path:?} did not exist in index at stage {}{}{}", *desired_stage as u8, stage_hint.map(|actual|format!(". It does exist at stage {}", actual as u8)).unwrap_or_default(), exists.then(|| ". It exists on disk").unwrap_or(". It does not exist on disk"))]
     IndexLookup {
         desired_path: BString,
         desired_stage: gix_index::entry::Stage,