@anysphere/file-service 0.0.0-b4c871b2 → 0.0.0-bf8eca2b

package/src/merkle_tree/local_construction.rs

@@ -1,15 +1,18 @@
+use crate::git_utils;
 use crate::merkle_tree::{
   File, MerkleNode, MerkleNodePtr, NodeType, PinnedFuture,
 };
 
 use super::{LocalConstruction, MerkleTree};
-use std::path::PathBuf;
-use std::{collections::HashMap, path::Path, sync::Arc};
+use std::collections::{BTreeMap, HashSet};
+use std::path::{Path, PathBuf};
 use tonic::async_trait;
 
 #[async_trait]
 impl LocalConstruction for MerkleTree {
-  async fn new(root_directory: Option<String>) -> Result<MerkleTree, anyhow::Error> {
+  async fn new(
+    root_directory: Option<String>,
+  ) -> Result<MerkleTree, anyhow::Error> {
     if let Some(root_directory) = root_directory {
       let n = MerkleTree::construct_merkle_tree(root_directory).await;
       return n;
@@ -25,32 +28,53 @@ impl LocalConstruction for MerkleTree {
   /// 2. compute hash for each file
   /// 3. construct merkle tree
   /// 4. return merkle tree
-  async fn construct_merkle_tree(root_directory: String) -> Result<MerkleTree, anyhow::Error> {
-    let path = PathBuf::from(root_directory.clone());
+  async fn construct_merkle_tree(
+    absolute_path_to_root_directory: String,
+  ) -> Result<MerkleTree, anyhow::Error> {
+    let path = PathBuf::from(absolute_path_to_root_directory.clone());
     if !path.exists() {
       // FIXME: we should report this via a good logger.
       panic!("Root directory does not exist!");
     }
 
-    let root_node = MerkleNode::new(path, None).await;
+    // 1. get all the gitignored files
+    let git_ignored_files = match git_utils::list_ignored_files(
+      absolute_path_to_root_directory.as_str(),
+      true,
+    ) {
+      Ok(git_ignored) => git_ignored,
+      Err(_e) => HashSet::new(),
+    };
+
+    tracing::info!("git_ignored_files: {:?}", git_ignored_files);
+
+    let root_node = MerkleNode::new(
+      path,
+      None,
+      &git_ignored_files,
+      absolute_path_to_root_directory.as_str(),
+    )
+    .await;
     let mut mt = MerkleTree {
       root: root_node,
-      files: HashMap::new(),
-      root_path: root_directory,
+      files: BTreeMap::new(),
+      root_path: absolute_path_to_root_directory,
+      cursor: None,
+      git_ignored_files,
     };
 
     // we now iterate over all the nodes and add them to the hashmap
     // TODO(later): i can make this parallel.
     fn add_nodes_to_hashmap<'a>(
       node: &'a MerkleNodePtr,
-      files: &'a mut HashMap<String, File>,
+      files: &'a mut BTreeMap<String, File>,
     ) -> PinnedFuture<'a, ()> {
       Box::pin(async move {
         let node_reader = node.read().await;
         match &node_reader.node_type {
           NodeType::Branch(n) => {
-						let children = &n.1;
-						files.insert(n.0.clone(), File { node: node.clone() });
+            let children = &n.1;
+            files.insert(n.0.clone(), File { node: node.clone() });
             for child in children {
               add_nodes_to_hashmap(child, files).await;
             }
@@ -102,9 +126,9 @@ impl LocalConstruction for MerkleTree {
       // File does not exist in the tree, let's add it.
       let e = self.attach_new_node_to_tree(file_path.clone()).await;
 
-			if e.is_err() {
-				return Err(anyhow::anyhow!("Could not attach new node to tree!"));
-			}
+      if e.is_err() {
+        return Err(anyhow::anyhow!("Could not attach new node to tree!"));
+      }
     }
 
     Ok(())
@@ -139,18 +163,17 @@ impl LocalConstruction for MerkleTree {
     let parent_node = parent_node.unwrap();
     let mut mut_parent = parent_node.write().await;
 
+    // BUG(sualeh): need to actually drop everything that is a child here.
+    // idea: enumerate all nodes that are children of this through a starts with query on the hashtable.
+    // then drop all of them.
+    // in opposite order of length.
 
-		// BUG(sualeh): need to actually drop everything that is a child here.
-		// idea: enumerate all nodes that are children of this through a starts with query on the hashtable.
-		// then drop all of them.
-		// in opposite order of length.
-
-		// then remove the node from the parent and you are done
+    // then remove the node from the parent and you are done
 
     // Remove the child from the parent node
     match mut_parent.node_type {
       NodeType::Branch(ref mut node) => {
-				let children = &mut node.1;
+        let children = &mut node.1;
         let mut found = false;
         let mut index = 0;