fix!: use PathStorageRef in place of &PathStorage

Author: Byron

gix-index/src/access/mod.rs

@@ -4,7 +4,7 @@ use std::ops::Range;
 use bstr::{BStr, ByteSlice, ByteVec};
 use filetime::FileTime;
 
-use crate::{entry, extension, Entry, PathStorage, State, Version};
+use crate::{entry, extension, Entry, PathStorage, PathStorageRef, State, Version};
 
 // TODO: integrate this somehow, somewhere, depending on later usage.
 #[allow(dead_code)]
@@ -41,7 +41,7 @@ impl State {
         &self.entries
     }
     /// Return our path backing, the place which keeps all paths one after another, with entries storing only the range to access them.
-    pub fn path_backing(&self) -> &PathStorage {
+    pub fn path_backing(&self) -> &PathStorageRef {
         &self.path_backing
     }
 
@@ -58,7 +58,7 @@ impl State {
     /// Return mutable entries along with their path, as obtained from `backing`.
     pub fn entries_mut_with_paths_in<'state, 'backing>(
         &'state mut self,
-        backing: &'backing PathStorage,
+        backing: &'backing PathStorageRef,
     ) -> impl Iterator<Item = (&'state mut Entry, &'backing BStr)> {
         self.entries.iter_mut().map(move |e| {
             let path = backing[e.path.clone()].as_bstr();
@@ -279,7 +279,7 @@ impl State {
     }
 
     /// Return a writable slice to entries and read-access to their path storage at the same time.
-    pub fn entries_mut_and_pathbacking(&mut self) -> (&mut [Entry], &PathStorage) {
+    pub fn entries_mut_and_pathbacking(&mut self) -> (&mut [Entry], &PathStorageRef) {
         (&mut self.entries, &self.path_backing)
     }
 

gix-index/src/entry/mod.rs

@@ -1,4 +1,8 @@
-/// The stage of an entry, one of 0 = base, 1 = ours, 2 = theirs
+/// The stage of an entry, one of…
+/// * 0 = no conflict,
+/// * 1 = base,
+/// * 2 = ours,
+/// * 3 = theirs
 pub type Stage = u32;
 
 ///
@@ -71,7 +75,7 @@ mod access {
             backing[self.path.clone()].as_bstr()
         }
 
-        /// Return an entry's stage.
+        /// Return an entry's stage. See [entry::Stage] for possible values.
         pub fn stage(&self) -> entry::Stage {
             self.flags.stage()
         }

gix-index/src/entry/stat.rs

@@ -92,21 +92,22 @@ impl Stat {
             size: fstat.len() as u32,
         };
         #[cfg(unix)]
-        use std::os::unix::fs::MetadataExt;
-        #[cfg(unix)]
-        let res = Stat {
-            mtime: mtime.try_into().unwrap_or_default(),
-            ctime: ctime.try_into().unwrap_or_default(),
-            // truncating to 32 bits is fine here because
-            // that's what the linux syscalls returns
-            // just rust upcasts to 64 bits for some reason?
-            // numbers this large are impractical anyway (that's a lot of hard-drives).
-            dev: fstat.dev() as u32,
-            ino: fstat.ino() as u32,
-            uid: fstat.uid(),
-            gid: fstat.gid(),
-            // truncation to 32 bits is on purpose (git does the same).
-            size: fstat.len() as u32,
+        let res = {
+            use std::os::unix::fs::MetadataExt;
+            Stat {
+                mtime: mtime.try_into().unwrap_or_default(),
+                ctime: ctime.try_into().unwrap_or_default(),
+                // truncating to 32 bits is fine here because
+                // that's what the linux syscalls returns
+                // just rust upcasts to 64 bits for some reason?
+                // numbers this large are impractical anyway (that's a lot of hard-drives).
+                dev: fstat.dev() as u32,
+                ino: fstat.ino() as u32,
+                uid: fstat.uid(),
+                gid: fstat.gid(),
+                // truncation to 32 bits is on purpose (git does the same).
+                size: fstat.len() as u32,
+            }
         };
 
         Ok(res)

gix-index/src/lib.rs

@@ -121,9 +121,10 @@ mod impls {
                     f,
                     "{} {}{:?} {} {}",
                     match entry.flags.stage() {
-                        0 => "BASE   ",
-                        1 => "OURS   ",
-                        2 => "THEIRS ",
+                        0 => "       ",
+                        1 => "BASE   ",
+                        2 => "OURS   ",
+                        3 => "THEIRS ",
                         _ => "UNKNOWN",
                     },
                     if entry.flags.is_empty() {