GitoxideLabs
diff --git a/‎gix-index/src/file/mod.rs‎
Lines changed: 48 additions & 1 deletion b/‎gix-index/src/file/mod.rs‎
Lines changed: 48 additions & 1 deletion
diff --git a/‎gix-index/src/lib.rs‎
Lines changed: 49 additions & 2 deletions b/‎gix-index/src/lib.rs‎
Lines changed: 49 additions & 2 deletions
diff --git a/‎gix-index/tests/fixtures/generated-archives/untracked_cache_empty.tar‎
0 Bytes b/‎gix-index/tests/fixtures/generated-archives/untracked_cache_empty.tar‎
0 Bytes
diff --git a/‎gix-index/tests/fixtures/generated-archives/untracked_cache_nested.tar‎
0 Bytes b/‎gix-index/tests/fixtures/generated-archives/untracked_cache_nested.tar‎
0 Bytes
@@ -21,17 +21,64 @@ mod impls {
 mod impl_ {
     use std::fmt::Formatter;
 
-    use crate::{File, State};
+    use crate::{Entry, File, PathStorageRef, State};
 
     impl std::fmt::Debug for File {
         fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+            if f.alternate() {
+                return f
+                    .debug_struct("File")
+                    .field("path", &self.path.display())
+                    .field("checksum", &self.checksum)
+                    .field("object_hash", &self.state.object_hash)
+                    .field("timestamp", &self.state.timestamp)
+                    .field("version", &self.state.version)
+                    .field(
+                        "entries",
+                        &EntriesDebug {
+                            entries: &self.state.entries,
+                            path_backing: &self.state.path_backing,
+                        },
+                    )
+                    .field("path_backing_size_bytes", &self.state.path_backing.len())
+                    .field("is_sparse", &self.state.is_sparse)
+                    .field("end_of_index_at_decode_time", &self.state.end_of_index_at_decode_time)
+                    .field("offset_table_at_decode_time", &self.state.offset_table_at_decode_time)
+                    .field("tree", &self.state.tree)
+                    .field("has_link", &self.state.link.is_some())
+                    .field("has_resolve_undo", &self.state.resolve_undo.is_some())
+                    .field("untracked", &self.state.untracked)
+                    .field("has_fs_monitor", &self.state.fs_monitor.is_some())
+                    .finish();
+            }
             f.debug_struct("File")
                 .field("path", &self.path.display())
                 .field("checksum", &self.checksum)
                 .finish_non_exhaustive()
         }
     }
 
+    struct EntriesDebug<'a> {
+        entries: &'a [Entry],
+        path_backing: &'a PathStorageRef,
+    }
+
+    impl std::fmt::Debug for EntriesDebug<'_> {
+        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+            if !f.alternate() {
+                return f.debug_list().entries(self.entries).finish();
+            }
+
+            writeln!(f, "[")?;
+            for entry in self.entries {
+                write!(f, "    ")?;
+                entry.fmt_debug(f, Some(self.path_backing))?;
+                writeln!(f, ",")?;
+            }
+            write!(f, "]")
+        }
+    }
+
     impl From<File> for State {
         fn from(f: File) -> Self {
             f.state
 
@@ -53,7 +53,7 @@ pub enum Version {
 }
 
 /// An entry in the index, identifying a non-tree item on disk.
-#[derive(Debug, Clone, Eq, PartialEq)]
+#[derive(Clone, Eq, PartialEq)]
 pub struct Entry {
     /// The filesystem stat information for the file on disk.
     pub stat: entry::Stat,
@@ -165,7 +165,54 @@ pub struct State {
 mod impls {
     use std::fmt::{Debug, Formatter};
 
-    use crate::{State, entry::Stage};
+    use crate::{Entry, PathStorageRef, State, entry::Stage};
+
+    impl Entry {
+        pub(crate) fn fmt_debug(&self, f: &mut Formatter, path_backing: Option<&PathStorageRef>) -> std::fmt::Result {
+            if f.alternate() {
+                write!(
+                    f,
+                    "{} {}{:?} mtime: {:?} {} ",
+                    match self.flags.stage() {
+                        Stage::Unconflicted => "       ",
+                        Stage::Base => "BASE   ",
+                        Stage::Ours => "OURS   ",
+                        Stage::Theirs => "THEIRS ",
+                    },
+                    if self.flags.is_empty() {
+                        "".to_string()
+                    } else {
+                        format!("{:?} ", self.flags)
+                    },
+                    self.mode,
+                    self.stat.mtime,
+                    self.id,
+                )?;
+                return match path_backing {
+                    Some(path_backing) => write!(f, "{}", self.path_in(path_backing)),
+                    None => write!(f, "{:?}", self.path),
+                };
+            }
+
+            let mut entry = f.debug_struct("Entry");
+            entry
+                .field("stat", &self.stat)
+                .field("id", &self.id)
+                .field("flags", &self.flags)
+                .field("mode", &self.mode);
+            match path_backing {
+                Some(path_backing) => entry.field("path", &self.path_in(path_backing)),
+                None => entry.field("path", &self.path),
+            }
+            .finish()
+        }
+    }
+
+    impl Debug for Entry {
+        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+            self.fmt_debug(f, None)
+        }
+    }
 
     impl Debug for State {
         fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {