@anysphere/file-service 0.0.0-e6124fba → 0.0.0-e68f3241

package/src/merkle_tree/mod.rs

@@ -1,1193 +0,0 @@
-use super::file_utils;
-use sha2::Digest;
-use std::collections::{BTreeMap, HashSet};
-use std::path::PathBuf;
-use std::vec;
-use std::{fs, path::Path, sync::Arc};
-use tokio::sync::RwLock;
-use tonic::async_trait;
-use tracing::info;
-
-pub mod local_construction;
-pub mod test;
-
-pub type MerkleNodePtr = Arc<RwLock<MerkleNode>>;
-
-pub struct MerkleTree {
-  root_path: String,
-  root: MerkleNodePtr,
-  files: BTreeMap<String, File>,
-  cursor: Option<usize>,
-  git_ignored_files_and_dirs: HashSet<String>,
-  is_git_repo: bool,
-}
-
-#[derive(Debug)]
-pub struct File {
-  node: MerkleNodePtr,
-}
-
-type FileName = String;
-type ParentPtr = Option<MerkleNodePtr>;
-
-#[derive(Debug)]
-pub enum NodeType {
-  Branch((FileName, Vec<MerkleNodePtr>)),
-  // this is the file_name
-  File(FileName),
-  ErrorNode((FileName, String)),
-}
-
-#[derive(Debug)]
-pub struct MerkleNode {
-  pub id: i32,
-  pub node_type: NodeType,
-  pub hash: String,
-  pub error: Option<String>,
-  pub parent: ParentPtr,
-}
-
-fn get_id() -> i32 {
-  rand::random::<i16>() as i32
-}
-
-// the merkle tree needs to implement 2 important traits
-// 1. the local construction and update trait. this makes sure that it works well locally!
-// 2. the remote sync trait. we need to make sure that it can be easily synced with the remote tree when necessary.
-
-#[async_trait]
-pub trait LocalConstruction {
-  async fn new(
-    root_directory: Option<String>,
-  ) -> Result<MerkleTree, anyhow::Error>;
-
-  async fn construct_merkle_tree(
-    root_directory: String,
-    git_ignored_files_and_dirs: HashSet<String>,
-    is_git_repo: bool
-  ) -> Result<MerkleTree, anyhow::Error>;
-
-  async fn update_file(
-    &mut self,
-    file_path: String,
-  ) -> Result<(), anyhow::Error>;
-
-  async fn delete_file(
-    &mut self,
-    file_path: String,
-  ) -> Result<(), anyhow::Error>;
-}
-
-// #[async_trait]
-// pub trait RemoteSync {
-//   async fn sync_with_remote(
-//     &mut self,
-//     client: super::RepositoryClient,
-//   ) -> Result<Vec<File>, tonic::Status>;
-//   async fn sync_subtree_node(
-//     &mut self,
-//     node: &MerkleNode,
-//     client: super::RepositoryClient,
-//   ) -> Result<Vec<File>, tonic::Status>;
-// }
-
-impl MerkleTree {
-  pub fn empty_tree() -> MerkleTree {
-    MerkleTree {
-      root: Arc::new(RwLock::new(MerkleNode::empty_node(None, None))),
-      files: BTreeMap::new(),
-      root_path: "".to_string(),
-      cursor: None,
-      git_ignored_files_and_dirs: HashSet::new(),
-      is_git_repo: false
-    }
-  }
-
-  pub async fn get_subtree_hash(
-    &self,
-    absolute_path: &str,
-  ) -> Result<String, anyhow::Error> {
-    let node = match self.files.get(absolute_path) {
-      Some(file) => file.node.clone(),
-      None => {
-        let all_files: Vec<String> = self.files.keys().cloned().collect();
-        return Err(anyhow::anyhow!(
-          "Could not find file in tree! Looking for: {}. All files: {:?}",
-          absolute_path,
-          all_files
-        ));
-      }
-    };
-
-    let node_reader = node.read().await;
-    let node_hash = node_reader.hash.clone();
-
-    info!(
-      "get_subtree_hash for path: {}, node_hash: {}",
-      absolute_path, node_hash
-    );
-
-    Ok(node_hash)
-  }
-
-  pub async fn get_num_embeddable_files(&self) -> Result<i32, anyhow::Error> {
-    let mut count = 0;
-
-    for (_, file) in &self.files {
-      let file_reader = file.node.read().await;
-      match &file_reader.node_type {
-        NodeType::File(_) => {
-          count += 1;
-        }
-        NodeType::Branch(_) => {
-          continue;
-        }
-        NodeType::ErrorNode(_) => {
-          continue;
-        }
-      }
-    }
-
-    Ok(count)
-  }
-
-  pub async fn get_num_embeddable_files_in_subtree(
-    &self,
-    absolute_path: PathBuf,
-  ) -> Result<i32, anyhow::Error> {
-    let mut count = 0;
-
-    let absolute_path = match absolute_path.to_str() {
-      Some(s) => s.to_string(),
-      None => {
-        return Err(anyhow::anyhow!(
-        "get_num_embeddable_files_in_subtree: Failed to convert path to string"
-      ))
-      }
-    };
-
-    // TODO(sualeh): worth keeping this list sorted. its now a btree
-
-    for (_, file) in &self.files {
-      let file_reader = file.node.read().await;
-      match &file_reader.node_type {
-        NodeType::File(file_name) => {
-          if file_name.contains(&absolute_path) {
-            count += 1;
-          }
-        }
-        NodeType::Branch(_) => {
-          continue;
-        }
-        NodeType::ErrorNode(_) => {
-          continue;
-        }
-      }
-    }
-
-    Ok(count)
-  }
-
-  pub async fn get_all_files(&self) -> Result<Vec<String>, anyhow::Error> {
-    let mut files = Vec::new();
-
-    for (file_name, file) in &self.files {
-      let file_reader = file.node.read().await;
-      match &file_reader.node_type {
-        NodeType::File(_) => {
-          files.push(file_name.clone());
-        }
-        NodeType::Branch(_) => {
-          continue;
-        }
-        NodeType::ErrorNode(_) => {
-          continue;
-        }
-      }
-    }
-
-    Ok(files)
-  }
-
-  pub async fn get_hashes_for_files(
-    &self,
-    files: Vec<String>,
-  ) -> Result<Vec<String>, anyhow::Error> {
-    let mut hashes = Vec::new();
-
-    for file_name in files {
-      let file = match self.files.get(&file_name) {
-        Some(file) => file,
-        None => {
-          return Err(anyhow::anyhow!("Could not find file in tree!"));
-        }
-      };
-
-      let file_reader = file.node.read().await;
-      match &file_reader.node_type {
-        NodeType::File(_) => {
-          hashes.push(file_reader.hash.clone());
-        }
-        NodeType::Branch(_) => {
-          continue;
-        }
-        NodeType::ErrorNode(_) => {
-          continue;
-        }
-      }
-    }
-
-    Ok(hashes)
-  }
-
-  /// Returns a filename, and then a path from its parent to the root (which can possibly be empty.)
-  pub async fn get_next_file_to_embed(
-    &mut self,
-  ) -> Result<(String, Vec<String>), anyhow::Error> {
-    // if the cursor is none, set it to 0
-    let cursor = match self.cursor {
-      Some(cursor) => cursor,
-      None => {
-        self.cursor = Some(0);
-        0
-      }
-    };
-
-    // get the thing at the cursor. while we dont find a file, we keep incrementing the cursor.
-    let mut cursor = cursor;
-    loop {
-      // O(log n)
-      let file = match self.files.values().nth(cursor) {
-        Some(file) => file,
-        None => {
-          return Err(anyhow::anyhow!("Could not find file to embed!"));
-        }
-      };
-
-      let file_reader = file.node.read().await;
-      match &file_reader.node_type {
-        NodeType::File(f) => {
-          // update the cursor.
-          self.cursor = Some(cursor + 1);
-          let spline = self.get_spline(f).await?;
-          return Ok((f.clone(), spline));
-        }
-        NodeType::Branch(_) => {
-          cursor += 1;
-          continue;
-        }
-        NodeType::ErrorNode(_) => {
-          cursor += 1;
-          continue;
-        }
-      }
-    }
-  }
-
-  pub async fn get_all_dir_files_to_embed(
-    &self,
-    absolute_path: &str,
-  ) -> Result<Vec<String>, anyhow::Error> {
-    let mut files = Vec::new();
-
-    // 1. should check that this absolute path is actually a directory.
-    let file_node = self.files.get(absolute_path);
-    if file_node.is_none() {
-      return Err(anyhow::anyhow!("Could not find directory the in tree!"));
-    }
-
-    for (file_path, f) in &self.files {
-      if !file_path.contains(absolute_path) {
-        continue;
-      }
-
-      match f.node.read().await.node_type {
-        NodeType::File(_) => {
-          files.push(file_path.clone());
-        }
-        NodeType::Branch(_) => {
-          continue;
-        }
-        NodeType::ErrorNode(_) => {
-          continue;
-        }
-      }
-    }
-
-    Ok(files)
-  }
-
-  // TODO(sualeh): i need tests for this!!
-  pub async fn get_spline(
-    &self,
-    absolute_path: &str,
-  ) -> Result<Vec<String>, anyhow::Error> {
-    let mut files = Vec::new();
-
-    let current_node = match self.files.get(absolute_path) {
-      Some(node) => {
-        node.node.clone()
-      }
-      None => {
-        return Err(anyhow::anyhow!("File not found: {}", absolute_path));
-      }
-    };
-
-    let mut stack = Vec::new();
-    stack.push(current_node);
-
-    while let Some(node) = stack.pop() {
-      let parent = node.read().await.parent.clone();
-      if let Some(parent) = parent {
-        {
-          let parent_node = parent.read().await;
-          match &parent_node.node_type {
-            NodeType::File(file_name) => {
-              files.push(file_name.clone());
-            }
-            NodeType::Branch((branch_name, _)) => {
-              files.push(branch_name.clone());
-            }
-            _ => {
-              continue;
-            }
-          }
-        }
-
-        stack.push(parent);
-      }
-    }
-    Ok(files)
-  }
-
-  /// creates a new node and attaches it to the current tree.
-  /// SPEC:
-  /// - you are allowed to create a file with a node such that the
-  ///   file is contained within the subtree defined by the root.
-  /// - updates the hash of the ancestor path.
-  /// - attaches to the ancestor.
-  /// - doenst add to the filemap
-  /// Primary usecase:
-  /// 1. when a new file is created.
-  /// Don't use it for:
-  /// 1. creating a full new tree.
-  /// Returns:
-  /// - the new node that was created.
-  async fn create_new_node_and_attach_to_ancestors(
-    &mut self,
-    file_path: PathBuf,
-  ) -> Result<MerkleNodePtr, anyhow::Error> {
-    // algorithm:
-    // 1. find the nearest parent before we reach the root.
-    // 2. if we don't find a parent, we should definitely return an error.
-    // 3. then we should create the chain of things down. then attach it to the parent we have.
-    let (ancestor, path) = match self.get_ancestor_in_tree(&file_path) {
-      Ok((ancestor, path)) => (ancestor, path),
-      Err(e) => {
-        return Err(anyhow::anyhow!(
-          "Could not find ancestor in tree! {}",
-          e.to_string()
-        ));
-      }
-    };
-
-    // 2 cases:
-    // 1. the path is empty. this means that the ancestor is the root.
-    // 2. the path is non-empty. that means there exist a non-empty element btwn till the root.
-
-    let absolute_root_path = self.root_path.clone();
-    let new_node = match path.len() {
-      0 => {
-        // this means that the ancestor is the root.
-        // we need to create a new node and attach it to the ancestor.
-        let new_node = MerkleNode::new(
-          file_path.clone(),
-          Some(ancestor.clone()),
-          &self.git_ignored_files_and_dirs,
-          &absolute_root_path.as_str(),
-          self.is_git_repo
-        )
-        .await;
-        ancestor.write().await.attach_child(new_node.clone()).await;
-        new_node
-      }
-      _ => {
-        // this means that the ancestor is not the root.
-        // we need to create a new node and attach it to the ancestor.
-
-        // UNSURE: not sure this is the correct thing to do but it is the fastest.
-        // get the last thing that is not in the tree.
-        let first_child_path = path.last().unwrap();
-        let first_child = MerkleNode::new(
-          first_child_path.clone(),
-          Some(ancestor.clone()),
-          &self.git_ignored_files_and_dirs,
-          &absolute_root_path.as_str(),
-          self.is_git_repo
-        )
-        .await;
-
-        // TODO(sualeh): we should do an assertion check that the entire vec is contained here.
-
-        // now we need to attach the first child to the ancestor.
-        let mut mut_ancestor = ancestor.write().await;
-        mut_ancestor.attach_child(first_child.clone()).await;
-        first_child
-      }
-    };
-
-    Ok(new_node)
-  }
-
-  /// Spec:
-  /// - adds to the tree but doesnt change things which already exist in the file.
-  async fn add_subtree_to_filemap(&mut self, node: MerkleNodePtr) {
-    // Traverse the subtree rooted at 'node' and add all the nodes to the file map
-    let mut stack = Vec::new();
-    stack.push(node);
-
-    while !stack.is_empty() {
-      // UNWRAP CHECKED AND FINE
-      let current_node = match stack.pop() {
-        Some(node) => node,
-        None => continue,
-      };
-
-      let node = current_node.read().await;
-      match &node.node_type {
-        NodeType::File(file_path) => {
-          // SUALEH BE CAREFUL!
-          match self.files.get(file_path) {
-            Some(file) => {
-              // check if the hash is the same:
-              let file_hash = file.node.read().await.hash.clone();
-
-              if file_hash != node.hash {
-                // update the file from the map.
-                self.files.insert(
-                  file_path.clone(),
-                  File {
-                    node: current_node.clone(),
-                  },
-                );
-              }
-            }
-            None => {
-              self.files.insert(
-                file_path.clone(),
-                File {
-                  node: current_node.clone(),
-                },
-              );
-            }
-          }
-        }
-        NodeType::Branch(node) => {
-          let children = &node.1;
-          for child in children {
-            stack.push(child.clone());
-          }
-        }
-        NodeType::ErrorNode(_) => {
-          continue;
-        }
-      }
-    }
-  }
-
-  /// PRECONDITION: the file exists in the tree!!
-  /// SPEC:
-  /// - attaches to the ancestor.
-  /// - adds to the filemap
-  /// - updates hashes of ancestor path.
-  async fn attach_new_node_to_tree(
-    &mut self,
-    file_path: String,
-  ) -> Result<(), anyhow::Error> {
-    let path = PathBuf::from(file_path.clone());
-    match self.create_new_node_and_attach_to_ancestors(path).await {
-      Ok(node_ptr) => {
-        self.add_subtree_to_filemap(node_ptr).await;
-        Ok(())
-      }
-      Err(e) => Err(anyhow::anyhow!(
-        "Could not create new node and attach to ancestors! {}",
-        e.to_string()
-      )),
-    }
-  }
-
-  /// MUTATES MUTATES MUTATES
-  /// Precondition:
-  /// - this can only be called on a file node!!!
-  async fn update_node(
-    &mut self,
-    node: MerkleNodePtr,
-  ) -> Result<(), anyhow::Error> {
-    let node_reader = node.read().await;
-
-    // first
-    let file_string = match &node_reader.node_type {
-      NodeType::File(file_path) => file_path,
-      NodeType::Branch(_) => {
-        // FIXME(sualeh): we shouldn't have panics around release time.
-        panic!("This should not happen!");
-      }
-      NodeType::ErrorNode(_) => {
-        panic!("This should not happen!");
-      }
-    };
-    let file_string = file_string.clone();
-    let file_path = PathBuf::from(file_string.clone());
-
-    println!("file_string: {:?}", file_string);
-    // get the parent, and remove this node from the parent.
-    let parent_node = node_reader.parent.clone();
-
-    match parent_node {
-      Some(parent_node) => {
-        let mut mut_parent = parent_node.write().await;
-
-        // check if the parent node has the children i want.
-        match mut_parent.node_type {
-          NodeType::Branch(ref mut node) => {
-            let children = &mut node.1;
-            let mut found = false;
-            let mut index = 0;
-
-            for (i, child) in children.iter().enumerate() {
-              match &child.read().await.node_type {
-                NodeType::File(child_file_path) => {
-                  if child_file_path == &file_string {
-                    found = true;
-                    index = i;
-                    break;
-                  }
-                }
-                NodeType::Branch(_) => {
-                  continue;
-                }
-                NodeType::ErrorNode(_) => {
-                  continue;
-                }
-              }
-            }
-
-            if found {
-              // remove the child from the parent.
-              let _ = children.remove(index);
-            }
-          }
-          NodeType::File(_) => {
-            panic!("This should not happen! I am a file node!");
-          }
-          NodeType::ErrorNode(_) => {
-            panic!("This should not happen! I am an error node!");
-          }
-        };
-      }
-      None => {
-        panic!("We should always have a parent :( ");
-      }
-    }
-
-    let node_ptr = self
-      .create_new_node_and_attach_to_ancestors(file_path)
-      .await;
-
-    match node_ptr {
-      Ok(node_ptr) => {
-        self.files.insert(
-          file_string,
-          File {
-            node: node_ptr.clone(),
-          },
-        );
-      }
-      Err(e) => {
-        return Err(anyhow::anyhow!(
-          "Could not create new node and attach to ancestors! {}",
-          e.to_string()
-        ));
-      }
-    }
-
-    Ok(())
-  }
-
-  fn get_parent_node<'a>(
-    &self,
-    file_path: &'a Path,
-  ) -> Result<MerkleNodePtr, anyhow::Error> {
-    let parent_name = file_path.parent();
-
-    match parent_name {
-      Some(parent_name) => {
-        // UNWRAP CHECKED AND FINE
-        println!("parent_name: {:?}", parent_name);
-        let parent_name = parent_name.to_str().unwrap().to_string();
-        let parent_node = match self.files.get(&parent_name) {
-          Some(file) => file.node.clone(),
-          None => {
-            return Err(anyhow::anyhow!("Could not get parent node! 2"));
-          }
-        };
-
-        Ok(parent_node)
-      }
-      None => {
-        return Err(anyhow::anyhow!("Could not get parent node! 3"));
-      }
-    }
-  }
-
-  /// SPEC:
-  /// This function retrieves the ancestor node in the Merkle tree for a given file path.
-  /// It returns a tuple containing the ancestor node and a vector of paths from the ancestor to the file.
-  /// If the file is not in the tree, an error is returned.
-  ///
-  /// Postcondition:
-  /// - the vector contains all the paths not including the ancestor itself.
-  ///
-  fn get_ancestor_in_tree<'a>(
-    &self,
-    file_path: &'a Path,
-  ) -> Result<(MerkleNodePtr, Vec<PathBuf>), anyhow::Error> {
-    let mut current_path = file_path;
-    let mut path_vec = Vec::new();
-    let root = self.root_path.clone();
-
-    if !current_path.to_str().unwrap().contains(&root) {
-      return Err(anyhow::anyhow!("File is not in the tree!"));
-    }
-
-    loop {
-      let parent_path = current_path.parent();
-
-      match parent_path {
-        Some(parent_path) => match parent_path.to_str() {
-          Some(parent_name) => {
-            if self.files.contains_key(parent_name) {
-              match self.files.get(parent_name) {
-                Some(file) => return Ok((file.node.clone(), path_vec)),
-                None => {
-                  return Err(anyhow::anyhow!(
-                    "Wow, this is weird. This should not happen!"
-                  ));
-                }
-              };
-            } else {
-              path_vec.push(parent_path.to_path_buf());
-              current_path = parent_path;
-            }
-          }
-          None => {
-            return Err(anyhow::anyhow!("Could not convert path to string!"));
-          }
-        },
-        None => {
-          return Err(anyhow::anyhow!("Couldn't find ancestor node!"));
-        }
-      };
-
-      // check if we are at the root.
-      if current_path.to_str().unwrap() == &root {
-        panic!("This should not happen!");
-      }
-    }
-  }
-}
-
-use std::future::Future;
-use std::pin::Pin;
-
-type PinnedFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
-type IgnoredFiles = HashSet<String>;
-
-impl MerkleNode {
-  /// please be careful using this.
-  async fn __new_unchecked(
-    file_or_directory: String,
-    parent: ParentPtr,
-    ignored_files: &IgnoredFiles,
-    absolute_root_path: &str,
-    is_git_repo: bool,
-  ) -> MerkleNodePtr {
-    // // check if the root is a git directory.
-    // let is_git_repo =
-    //   match git_utils::is_git_directory(absolute_root_path).await {
-    //     Ok(is_git_repo) => is_git_repo,
-    //     Err(_e) => false,
-    //   };
-    let bypass_git = !is_git_repo;
-
-    MerkleNode::construct_node(
-      Path::new(&file_or_directory),
-      parent,
-      ignored_files,
-      absolute_root_path,
-      bypass_git,
-    )
-    .await
-  }
-
-  async fn new(
-    absolute_file_or_directory: PathBuf,
-    parent: ParentPtr,
-    ignored_files: &IgnoredFiles,
-    absolute_root_path: &str,
-    is_git_repo: bool,
-  ) -> MerkleNodePtr {
-    let bypass_git = !is_git_repo;
-
-    info!(
-      "constructing node for absolute_file_or_directory: {:?}",
-      absolute_file_or_directory
-    );
-
-    MerkleNode::construct_node(
-      Path::new(&absolute_file_or_directory),
-      parent,
-      ignored_files,
-      absolute_root_path,
-      bypass_git,
-    )
-    .await
-  }
-
-  /// NOT added to the tree by default.
-  // async fn from_file(file_path: String) -> MerkleNode {
-  // 	let path = Path::new(&file_path);
-  // 	if path.exists() {
-  // 		// Update the file in two places.
-  // 		let file_hash = self.files.get_mut(&file_path).unwrap();
-
-  fn construct_node<'a>(
-    absolute_file_or_directory: &'a Path,
-    parent: ParentPtr,
-    ignored_files: &'a IgnoredFiles,
-    absolute_root_path: &'a str,
-    bypass_git: bool,
-  ) -> PinnedFuture<'a, MerkleNodePtr> {
-    Box::pin(async move {
-      // check if it is a file
-      let path_str = absolute_file_or_directory.to_str().unwrap().to_string();
-      if absolute_file_or_directory.is_file() {
-        return Arc::new(RwLock::new(
-          MerkleNode::construct_file_node_or_error_node(
-            absolute_file_or_directory,
-            parent,
-            ignored_files,
-          )
-          .await,
-        ));
-      }
-
-      // check if the directory fails the bad dir test.
-      let is_bad_dir = file_utils::is_in_bad_dir(absolute_file_or_directory);
-      if is_bad_dir.is_err() || is_bad_dir.unwrap_or(false) {
-        // println!("skipping directory: {}", path_str);
-        return Arc::new(RwLock::new(MerkleNode::empty_node(
-          Some(absolute_file_or_directory),
-          Some("Directory is in bad dir!".to_string()),
-        )));
-      }
-
-      let is_git_ignored_dir = ignored_files.contains(&path_str);
-
-      if is_git_ignored_dir && !bypass_git {
-        return Arc::new(RwLock::new(MerkleNode::empty_node(
-          Some(absolute_file_or_directory),
-          Some("Directory is git ignored!".to_string()),
-        )));
-      }
-
-      let entries = fs::read_dir(absolute_file_or_directory);
-      match entries {
-        Ok(_) => (),
-        Err(e) => {
-          return Arc::new(RwLock::new(MerkleNode::empty_node(
-            Some(absolute_file_or_directory),
-            Some(e.to_string()),
-          )));
-        }
-      }
-      let entries = entries.unwrap();
-      let mut children = Vec::<MerkleNodePtr>::new();
-
-      let node = Arc::new(RwLock::new(MerkleNode {
-        id: get_id(),
-        node_type: NodeType::Branch((path_str.clone(), vec![])),
-        hash: "".to_string(),
-        error: None,
-        parent,
-      }));
-
-      for entry in entries {
-        match entry {
-          Ok(entry) => {
-            children.push(
-              MerkleNode::construct_node(
-                &entry.path(),
-                Some(node.clone()),
-                ignored_files,
-                absolute_root_path,
-                bypass_git,
-              )
-              .await,
-            );
-          }
-          Err(e) => {
-            children.push(Arc::new(RwLock::new(MerkleNode::empty_node(
-              Some(absolute_file_or_directory),
-              Some(e.to_string()),
-            ))));
-          }
-        }
-      }
-
-      let node_hash = MerkleNode::compute_branch_hash(&children).await;
-      // get a write lock on the node
-      let mut node_writer = node.write().await;
-      node_writer.node_type = NodeType::Branch((path_str.clone(), children));
-      node_writer.hash = node_hash.clone();
-      // release the lock
-      drop(node_writer);
-
-      node
-    })
-  }
-
-  async fn construct_file_node(
-    absolute_file_path: &Path,
-    parent: ParentPtr,
-    ignored_files: &IgnoredFiles,
-  ) -> Result<MerkleNode, String> {
-    let file_str = absolute_file_path
-      .to_str()
-      .ok_or("Could not convert file path to string!")?
-      .to_string();
-    // first see if it passes the
-    match file_utils::is_good_file(absolute_file_path) {
-      Ok(_) => {}
-      Err(e) => {
-        return Err(format!("File failed runtime checks! {}", e.to_string()));
-      }
-    }
-
-    // check if the file is in the git ignore buffer.
-    // this is a bug right because we are not checking absoluteness here.
-    match ignored_files.contains(&file_str) {
-      true => {
-        return Err(format!("File is in git ignore buffer!"));
-      }
-      false => {}
-    }
-
-    // check if the file passes runtime checks.
-    match file_utils::is_good_file_runtime_check(
-      absolute_file_path,
-      // &file_content,
-    )
-    .await
-    {
-      Ok(_) => {}
-      Err(e) => {
-        return Err(format!("File failed runtime checks! {}", e.to_string()));
-      }
-    }
-
-    // read the file_content to a buffer
-    let file_content =
-      match file_utils::read_string_without_bom(absolute_file_path).await {
-        Ok(content) => content,
-        Err(e) => {
-          return Err(format!("Could not read file! {}", e.to_string()));
-        }
-      };
-
-    let file_hash = compute_hash(&file_content);
-    let node = MerkleNode {
-      id: get_id(),
-      node_type: NodeType::File(file_str),
-      hash: file_hash.clone(),
-      error: None,
-      parent,
-    };
-
-    Ok(node)
-  }
-
-  async fn construct_file_node_or_error_node(
-    absolute_file_path: &Path,
-    parent: ParentPtr,
-    ignored_files: &IgnoredFiles,
-  ) -> MerkleNode {
-    let node = match MerkleNode::construct_file_node(
-      absolute_file_path,
-      parent,
-      ignored_files,
-    )
-    .await
-    {
-      Ok(node) => node,
-      Err(e) => {
-        // println!("constructing error node. error: {}", e);
-        // println!("file_path: {:?}", file_path);
-        MerkleNode::empty_node(Some(absolute_file_path), Some(e))
-      }
-    };
-
-    node
-  }
-
-  /// PRECONDITION: this must be a branch node.
-  async fn attach_child(&mut self, child: MerkleNodePtr) {
-    match &mut self.node_type {
-      NodeType::Branch(node) => {
-        let children = &mut node.1;
-        children.push(child);
-        self.update_hash_of_ancestor_path();
-      }
-      NodeType::File(_) => {
-        panic!("This should not happen!");
-      }
-      NodeType::ErrorNode(_) => {
-        panic!("This should not happen!");
-      }
-    }
-  }
-
-  async fn compute_branch_hash(children: &[MerkleNodePtr]) -> String {
-    let mut hasher = sha2::Sha256::new();
-    let mut names_and_hashes = vec![];
-    let mut non_zero_children = 0;
-
-    for child in children {
-      // check if it is an error node
-      let child_reader = child.read().await;
-
-      match &child_reader.node_type {
-        NodeType::File(file_name) => {
-          non_zero_children += 1;
-          names_and_hashes.push((file_name.clone(), child_reader.hash.clone()));
-        }
-        NodeType::Branch((file_name, _)) => {
-          let hash = child_reader.hash.clone();
-          if hash == "" {
-            continue;
-          }
-
-          non_zero_children += 1;
-          names_and_hashes.push((file_name.clone(), hash));
-        }
-        NodeType::ErrorNode(_) => {
-          continue;
-        }
-      }
-    }
-
-    // sort the list of names and hashes by the hashes!!
-    names_and_hashes
-      .sort_by(|a, b| a.1.to_lowercase().cmp(&b.1.to_lowercase()));
-
-    for (name, hash) in names_and_hashes {
-      if hash == "" {
-        continue;
-      }
-      info!("name: {}, hash: {}", name, hash);
-      hasher.update(hash);
-    }
-
-    if non_zero_children == 0 {
-      // this means that the branch is empty.
-      // we should return an empty string.
-      return "".to_string();
-    }
-
-    let result = hasher.finalize();
-    format!("{:x}", result)
-  }
-
-  fn update_hash_of_ancestor_path<'a>(&'a mut self) -> PinnedFuture<'a, ()> {
-    Box::pin(async move {
-      self.hash = match &self.node_type {
-        NodeType::Branch(node) => {
-          let children = &node.1;
-          MerkleNode::compute_branch_hash(children).await
-        }
-        NodeType::File(_) => {
-          panic!("This should not happen!");
-        }
-        NodeType::ErrorNode(_) => {
-          panic!("This should not happen!");
-        }
-      };
-
-      // propogate it up to the parents as long as they are not null
-      match &self.parent {
-        Some(parent) => {
-          let mut mut_parent = parent.write().await;
-          mut_parent.update_hash_of_ancestor_path().await;
-        }
-        None => {
-          println!("This node has no parent!");
-        }
-      }
-    })
-  }
-
-  fn empty_node(file_name: Option<&Path>, error: Option<String>) -> MerkleNode {
-    if let Some(file_name) = file_name {
-      let file_name = file_name.to_str();
-      match file_name {
-        Some(file_name) => {
-          return MerkleNode {
-            id: get_id(),
-            node_type: NodeType::ErrorNode((
-              file_name.to_string(),
-              error.clone().unwrap_or_default(),
-            )),
-            hash: "".to_string(),
-            error,
-            parent: None,
-          };
-        }
-        None => {
-          return MerkleNode {
-            id: get_id(),
-            node_type: NodeType::ErrorNode((
-              "".to_string(),
-              error.clone().unwrap_or_default(),
-            )),
-            hash: "".to_string(),
-            error: Some(
-              "FilenameError: Could not convert file name to string!"
-                .to_string()
-                + &error.unwrap_or_default(),
-            ),
-            parent: None,
-          };
-        }
-      }
-    } else {
-      return MerkleNode {
-        id: -1,
-        node_type: NodeType::ErrorNode((
-          "".to_string(),
-          error.clone().unwrap_or_default(),
-        )),
-        hash: "".to_string(),
-        error,
-        parent: None,
-      };
-    }
-  }
-
-  fn fmt(
-    &self,
-    f: &mut std::fmt::Formatter<'_>,
-    indent: usize,
-  ) -> std::fmt::Result {
-    match &self.node_type {
-      NodeType::Branch(node) => {
-        // print yourself
-        writeln!(f, "{}BRANCH", " ".repeat(indent * 2))?;
-        writeln!(
-          f,
-          "{}ID: {}, Hash: {}\n",
-          " ".repeat(indent * 2),
-          self.id,
-          self.hash
-        )?;
-
-        for child in &node.1 {
-          let child_read = child.try_read();
-          if child_read.is_err() {
-            writeln!(f, "------")?;
-            writeln!(f, "Could not get read lock on a child node!")?;
-            writeln!(f, "------")?;
-          }
-          child_read.unwrap().fmt(f, indent + 1)?;
-        }
-      }
-      NodeType::File(file_name) => {
-        writeln!(f, "{}FILE", " ".repeat(indent * 2))?;
-        if let Some(error) = &self.error {
-          writeln!(
-            f,
-            "{}ID: {}, File: {}, Hash: {} Error: {}",
-            " ".repeat(indent * 2),
-            self.id,
-            file_name,
-            self.hash,
-            error
-          )?;
-        } else {
-          writeln!(
-            f,
-            "{}ID: {}, File: {}, Hash: {}",
-            " ".repeat(indent * 2),
-            self.id,
-            file_name,
-            self.hash,
-          )?;
-        }
-      }
-      NodeType::ErrorNode(error) => {
-        writeln!(f, "{}Error Node:", " ".repeat(indent * 2))?;
-        writeln!(f, "{}file: {}", " ".repeat(indent * 2), error.0)?;
-        writeln!(f, "{}error: {}", " ".repeat(indent * 2), error.1)?;
-      }
-    }
-    Ok(())
-  }
-}
-
-fn compute_hash(file_content: &str) -> String {
-  let mut hasher = sha2::Sha256::new();
-  hasher.update(file_content);
-  let result = hasher.finalize();
-
-  format!("{:x}", result)
-}
-
-impl std::fmt::Display for MerkleTree {
-  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    write!(f, "---------------------------------\n")?;
-    let root = self.root.try_read();
-    if root.is_err() {
-      write!(f, "Could not get read lock on root node!")?;
-      write!(f, "the root path is: {}", self.root_path)?;
-      write!(f, "---------------------------------\n")?;
-      return Ok(());
-    }
-
-    // UNWRAP CHECKED AND FINE
-    let root = root.unwrap();
-    write!(f, "MerkleTree with root hash: {}\n", root.hash)?;
-    write!(f, "Tree:\n{}\n", root)?;
-    // dont uncomment: this will be an infinite loop
-    // write!(f, "Files: {:#?}\n", self.files)?;
-    write!(f, "Number of files: {}\n", self.files.len())?;
-    write!(f, "---------------------------------\n")
-  }
-}
-
-impl std::fmt::Display for MerkleNode {
-  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    self.fmt(f, 0)
-  }
-}
-
-impl std::fmt::Display for NodeType {
-  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    match self {
-      NodeType::Branch(_) => write!(f, "Branch"),
-      NodeType::File(file_name) => write!(f, "File: {}", file_name),
-      NodeType::ErrorNode((file_name, error)) => {
-        write!(f, "ErrorNode: {} {}", file_name, error)
-      }
-    }
-  }
-}