Verify entry order (#293)

Author: Byron

git-index/src/entry.rs

@@ -140,5 +140,26 @@ mod access {
         pub fn path<'a>(&self, state: &'a State) -> &'a BStr {
             (&state.path_backing[self.path.clone()]).as_bstr()
         }
+
+        pub fn stage(&self) -> u32 {
+            self.flags.stage()
+        }
+    }
+}
+
+mod _impls {
+    use crate::{Entry, State};
+    use std::cmp::Ordering;
+
+    impl Entry {
+        pub fn cmp(&self, other: &Self, state: &State) -> Ordering {
+            let lhs = self.path(state);
+            let rhs = other.path(state);
+            let common_len = lhs.len().min(rhs.len());
+            lhs[..common_len]
+                .cmp(&rhs[..common_len])
+                .then_with(|| lhs.len().cmp(&rhs.len()))
+                .then_with(|| self.stage().cmp(&other.stage()))
+        }
     }
 }

git-index/src/file/verify.rs

@@ -1,7 +1,7 @@
 use crate::File;
 use std::sync::atomic::AtomicBool;
 
-pub mod error {
+mod error {
     use quick_error::quick_error;
 
     quick_error! {

git-index/src/lib.rs

@@ -15,6 +15,8 @@ mod access;
 
 pub mod decode;
 
+pub mod verify;
+
 /// All known versions of a git index file.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
 #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]

git-index/src/verify.rs

@@ -0,0 +1,37 @@
+use crate::State;
+use std::cmp::Ordering;
+
+pub mod entries {
+    use bstr::BString;
+    use quick_error::quick_error;
+
+    quick_error! {
+        #[derive(Debug)]
+        pub enum Error {
+            OutOfOrder { current_index: usize, current_path: BString, current_stage: u8, previous_path: BString, previous_stage: u8 } {
+                display("todo")
+            }
+        }
+    }
+}
+
+impl State {
+    pub fn verify_entries(&self) -> Result<(), entries::Error> {
+        let mut previous = None::<&crate::Entry>;
+        for (idx, entry) in self.entries.iter().enumerate() {
+            if let Some(prev) = previous {
+                if prev.cmp(entry, self) != Ordering::Less {
+                    return Err(entries::Error::OutOfOrder {
+                        current_index: idx,
+                        current_path: entry.path(self).into(),
+                        current_stage: entry.flags.stage() as u8,
+                        previous_path: prev.path(self).into(),
+                        previous_stage: prev.flags.stage() as u8,
+                    });
+                }
+            }
+            previous = Some(entry);
+        }
+        Ok(())
+    }
+}

git-index/tests/index/file/mod.rs

@@ -5,21 +5,24 @@ mod init {
     use git_index::{entry, Version};
     use git_testtools::hex_to_id;
 
+    fn verify(index: git_index::File) -> git_index::File {
+        index.verify_integrity().unwrap();
+        index.verify_entries().unwrap();
+        index
+    }
+
     fn loose_file(name: &str) -> git_index::File {
         let path = git_testtools::fixture_path(Path::new("loose_index").join(name).with_extension("git-index"));
         let file = git_index::File::at(path, git_index::decode::Options::default()).unwrap();
-        file.verify_integrity().unwrap();
-        file
+        verify(file)
     }
     fn file(name: &str) -> git_index::File {
         let file = git_index::File::at(crate::fixture_path(name), git_index::decode::Options::default()).unwrap();
-        file.verify_integrity().unwrap();
-        file
+        verify(file)
     }
     fn file_opt(name: &str, opts: git_index::decode::Options) -> git_index::File {
         let file = git_index::File::at(crate::fixture_path(name), opts).unwrap();
-        file.verify_integrity().unwrap();
-        file
+        verify(file)
     }
 
     #[test]