parse TREE chunk (#293)

For now the data structure is just 'as-written' and we see what
needs to change there as we have to maintain it.

Author: Byron

Cargo.lock

@@ -25,6 +25,7 @@ filetime = "0.2.15"
 
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
 smallvec = "1.7.0"
+atoi = "0.4.0"
 
 [dev-dependencies]
 git-testtools = { path = "../tests/tools"}

git-index/Cargo.toml

@@ -73,14 +73,16 @@ impl State {
     pub fn from_bytes(data: &[u8], timestamp: FileTime, object_hash: git_hash::Kind) -> Result<Self, Error> {
         let (version, num_entries, post_header_data) = header::decode(&data, object_hash)?;
         let start_of_extensions = extension::end_of_index_entry::decode(&data, object_hash);
+        let mut cache_tree = None;
+
+        // Note that we ignore all errors for optional signatures.
         match start_of_extensions {
             Some(offset) => {
                 let extensions = extension::Iter::new_without_checksum(&data[offset..], object_hash);
                 for (signature, ext_data) in extensions {
                     match signature {
                         extension::tree::SIGNATURE => {
-                            let tree = extension::tree::decode(ext_data, object_hash);
-                            todo!("put tree somewhere")
+                            cache_tree = extension::tree::decode(ext_data, object_hash);
                         }
                         extension::end_of_index_entry::SIGNATURE => {} // skip already done
                         _unknown => {}                                 // skip unknown extensions, too
@@ -91,6 +93,10 @@ impl State {
             None => todo!("load entries singlge-threaded, then extensions"),
         }
 
-        Ok(State { timestamp, version })
+        Ok(State {
+            timestamp,
+            version,
+            cache_tree,
+        })
     }
 }

git-index/src/decode.rs

@@ -11,10 +11,14 @@ fn decode_header(data: &[u8]) -> (Signature, u32, &[u8]) {
     (signature.try_into().unwrap(), read_u32(size), data)
 }
 
+/// A structure to associate object ids of a tree with sections in the index entries list.
+///
+/// It allows to more quickly build trees by avoiding as it can quickly re-use portions of the index and its associated tree ids
+/// if there wa sno change to them. Portions of this tree are invalidated as the index is changed.
 pub struct Tree {
+    name: SmallVec<[u8; 23]>,
     /// Only set if there are any entries in the index we are associated with.
     id: Option<tree::NodeId>,
-    name: SmallVec<[u8; 23]>,
     children: Vec<Tree>,
 }
 

git-index/src/extension/mod.rs

@@ -1,4 +1,6 @@
 use crate::extension::{Signature, Tree};
+use crate::util::split_at_byte_exclusive;
+use git_hash::ObjectId;
 
 pub const SIGNATURE: Signature = *b"TREE";
 
@@ -11,7 +13,50 @@ pub struct NodeId {
 
 /// A recursive data structure
 pub fn decode(data: &[u8], object_hash: git_hash::Kind) -> Option<Tree> {
-    todo!("decode tree")
+    let (tree, data) = one_recursive(data, object_hash.len_in_bytes())?;
+    assert!(
+        data.is_empty(),
+        "BUG: should fully consume the entire tree extension chunk, got {} left",
+        data.len()
+    );
+    Some(tree)
+}
+
+pub fn one_recursive(data: &[u8], hash_len: usize) -> Option<(Tree, &[u8])> {
+    let (path, data) = split_at_byte_exclusive(data, 0)?;
+
+    let (entry_count, data) = split_at_byte_exclusive(data, b' ')?;
+    let entry_count: u32 = atoi::atoi(entry_count)?;
+
+    let (subtree_count, mut data) = split_at_byte_exclusive(data, b'\n')?;
+    let subtree_count: usize = atoi::atoi(subtree_count)?;
+
+    let node_id = (entry_count != 0)
+        .then(|| {
+            (data.len() >= hash_len).then(|| {
+                let (hash, rest) = data.split_at(hash_len);
+                data = rest;
+                ObjectId::from(hash)
+            })
+        })
+        .flatten()
+        .map(|id| NodeId { id, entry_count });
+
+    let mut subtrees = Vec::with_capacity(subtree_count);
+    for _ in 0..subtree_count {
+        let (tree, rest) = one_recursive(data, hash_len)?;
+        subtrees.push(tree);
+        data = rest;
+    }
+
+    Some((
+        Tree {
+            id: node_id,
+            name: path.into(),
+            children: subtrees,
+        },
+        data,
+    ))
 }
 
 #[cfg(test)]

git-index/src/extension/tree.rs

@@ -30,7 +30,8 @@ pub mod init {
         fn new() -> Self {
             State {
                 timestamp: FileTime::from_system_time(std::time::SystemTime::UNIX_EPOCH),
-                version: Version::V4,
+                version: Version::V3,
+                cache_tree: None,
             }
         }
     }
@@ -71,11 +72,29 @@ pub struct State {
     /// same timestamp as this as potentially changed, checking more thoroughly if a change actually happened.
     timestamp: FileTime,
     version: Version,
+    pub cache_tree: Option<extension::Tree>,
 }
 
 pub(crate) mod util {
     #[inline]
     pub fn read_u32(b: &[u8]) -> u32 {
         u32::from_be_bytes(b.try_into().unwrap())
     }
+
+    #[inline]
+    pub fn split_at_byte_exclusive(data: &[u8], byte: u8) -> Option<(&[u8], &[u8])> {
+        if data.len() < 2 {
+            return None;
+        }
+        data.iter().enumerate().find_map(|(idx, b)| {
+            (*b == byte).then(|| {
+                if idx == 0 {
+                    (&[] as &[u8], &data[1..])
+                } else {
+                    let (a, b) = data.split_at(idx);
+                    (a, &b[1..])
+                }
+            })
+        })
+    }
 }

git-index/src/lib.rs

@@ -6,6 +6,7 @@ mod init {
     }
 
     #[test]
+    #[ignore]
     fn read_v2_with_single_entry_tree() {
         let file = file("v2");
         assert_eq!(file.version(), Version::V2);