First stab at tree verification (#293)

Author: Byron

git-index/src/extension/mod.rs

@@ -57,7 +57,7 @@ pub(crate) mod fs_monitor;
 
 pub(crate) mod decode;
 
-pub(crate) mod tree;
+pub mod tree;
 
 pub(crate) mod end_of_index_entry;
 

git-index/src/extension/tree.rs

@@ -1,3 +1,4 @@
+use bstr::ByteSlice;
 use git_hash::ObjectId;
 
 use crate::util::split_at_pos;
@@ -8,6 +9,65 @@ use crate::{
 
 pub const SIGNATURE: Signature = *b"TREE";
 
+pub mod verify {
+    use bstr::BString;
+    use quick_error::quick_error;
+
+    quick_error! {
+        #[derive(Debug)]
+        pub enum Error {
+            RootWithName { name: BString } {
+                display("The root tree was named '{}', even though it should be empty", name)
+            }
+            EntriesCount {actual: u32, expected: u32 } {
+                display("Expected not more than {} entries to be reachable from the top-level, but actual count was {}", expected, actual)
+            }
+        }
+    }
+}
+
+impl Tree {
+    pub fn verify(&self) -> Result<(), verify::Error> {
+        fn verify_recursive(children: &[Tree]) -> Result<Option<u32>, verify::Error> {
+            if children.is_empty() {
+                return Ok(None);
+            }
+            let mut entries = 0;
+            for child in children {
+                let actual_num_entries = verify_recursive(&child.children)?;
+                if let Some(actual) = actual_num_entries {
+                    if actual > child.num_entries {
+                        return Err(verify::Error::EntriesCount {
+                            actual,
+                            expected: child.num_entries,
+                        });
+                    }
+                }
+                entries += child.num_entries;
+            }
+            Ok(entries.into())
+        }
+
+        if !self.name.is_empty() {
+            return Err(verify::Error::RootWithName {
+                name: self.name.as_bstr().into(),
+            });
+        }
+
+        let declared_entries = verify_recursive(&self.children)?;
+        if let Some(actual) = declared_entries {
+            if actual > self.num_entries {
+                return Err(verify::Error::EntriesCount {
+                    actual,
+                    expected: self.num_entries,
+                });
+            }
+        }
+
+        Ok(())
+    }
+}
+
 /// A recursive data structure
 pub fn decode(data: &[u8], object_hash: git_hash::Kind) -> Option<Tree> {
     let (tree, data) = one_recursive(data, object_hash.len_in_bytes())?;

git-index/src/verify.rs

@@ -9,7 +9,23 @@ pub mod entries {
         #[derive(Debug)]
         pub enum Error {
             OutOfOrder { current_index: usize, current_path: BString, current_stage: u8, previous_path: BString, previous_stage: u8 } {
-                display("todo")
+                display("Entry '{}' (stage = {}) at index {} should order after prior entry '{}' (stage = {})", current_path, current_stage, current_index, previous_path, previous_stage)
+            }
+        }
+    }
+}
+
+pub mod extensions {
+    use crate::extension;
+    use quick_error::quick_error;
+
+    quick_error! {
+        #[derive(Debug)]
+        pub enum Error {
+            Tree(err: extension::tree::verify::Error) {
+                display("The tree extension wasn't valid")
+                source(err)
+                from()
             }
         }
     }
@@ -34,4 +50,11 @@ impl State {
         }
         Ok(())
     }
+
+    pub fn verify_extensions(&self) -> Result<(), extensions::Error> {
+        self.tree().map(|t| t.verify()).transpose()?;
+        // TODO: verify links by running the whole set of tests on the index
+        //       - do that once we load it as well, or maybe that's lazy loaded? Too many questions for now.
+        Ok(())
+    }
 }

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

@@ -8,6 +8,7 @@ mod init {
     fn verify(index: git_index::File) -> git_index::File {
         index.verify_integrity().unwrap();
         index.verify_entries().unwrap();
+        index.verify_extensions().unwrap();
         index
     }
 

gitoxide-core/src/index/mod.rs

@@ -19,6 +19,7 @@ pub fn verify(
     let file = parse_file(index_path, object_hash)?;
     file.verify_integrity()?;
     file.verify_entries()?;
+    file.verify_extensions()?;
     #[cfg_attr(not(feature = "serde1"), allow(irrefutable_let_patterns))]
     if let crate::OutputFormat::Human = format {
         writeln!(out, "OK").ok();