feat: entry::Stage can now be converted into entry::Flags.

This makes it easier to change the stage of an entry.

Author: Byron

gix-index/src/decode/entries.rs

@@ -64,9 +64,7 @@ pub fn chunk<'a>(
         .ok_or(decode::Error::Entry { index: idx })?;
 
         data = remaining;
-        if entry.mode.is_sparse() {
-            is_sparse = true;
-        }
+        is_sparse |= entry.mode.is_sparse();
         // TODO: entries are actually in an intrusive collection, with path as key. Could be set for us. This affects 'ignore_case' which we
         //       also don't yet handle but probably could, maybe even smartly with the collection.
         //       For now it's unclear to me how they access the index, they could iterate quickly, and have fast access by path.

gix-index/src/entry/flags.rs

@@ -60,6 +60,11 @@ bitflags! {
 }
 
 impl Flags {
+    /// Create a new instance whose stage is set to `stage`.
+    pub fn from_stage(stage: Stage) -> Self {
+        Flags::from_bits((stage as u32) << 12).expect("stage can only be valid flags")
+    }
+
     /// Return the stage as extracted from the bits of this instance.
     pub fn stage(&self) -> Stage {
         match self.stage_raw() {
@@ -96,6 +101,12 @@ impl Flags {
     }
 }
 
+impl From<Stage> for Flags {
+    fn from(value: Stage) -> Self {
+        Flags::from_stage(value)
+    }
+}
+
 pub(crate) mod at_rest {
     use bitflags::bitflags;
 

gix-index/tests/index/entry/mod.rs

@@ -1,3 +1,16 @@
+mod flags {
+    use gix_index::entry::{Flags, Stage};
+
+    #[test]
+    fn from_stage() {
+        for stage in [Stage::Unconflicted, Stage::Base, Stage::Ours, Stage::Theirs] {
+            let actual = Flags::from_stage(stage);
+            assert_eq!(actual.stage(), stage);
+            let actual: Flags = stage.into();
+            assert_eq!(actual.stage(), stage);
+        }
+    }
+}
 mod mode;
 mod stat;
 mod time;

gix-index/tests/index/entry/mode.rs

@@ -12,3 +12,18 @@ fn apply() {
         Mode::SYMLINK
     );
 }
+
+#[test]
+fn debug() {
+    assert_eq!(
+        format!("{:?}", Mode::FILE),
+        "Mode(FILE)",
+        "Assure the debug output is easy to understand"
+    );
+
+    assert_eq!(
+        format!("{:?}", Mode::from_bits(0o120744)),
+        "Some(Mode(FILE | SYMLINK | 0x40))",
+        "strange modes are also mostly legible"
+    );
+}