@anysphere/file-service 0.0.0-ebd74baa → 0.0.0-ec067eac

package/src/git_utils.rs

@@ -1,355 +0,0 @@
-use std::collections::HashSet;
-use std::path::MAIN_SEPARATOR_STR;
-use std::process::Command;
-
-pub fn list_ignored_files_and_directories(
-  workspace_root_path: &str,
-  should_return_absolute_paths: bool,
-) -> Result<HashSet<String>, Box<dyn std::error::Error>> {
-  let mut gitignored_files = HashSet::new();
-
-  let commands = vec![
-    vec![
-      "git",
-      "ls-files",
-      "--others",
-      "--ignored",
-      "--exclude-standard",
-      "--directory",
-      "--no-empty-directory"
-    ],
-    // FIXME(sualeh): this is super sketchy and might totally break in like a bazillion ways. i dont like it.
-    vec![
-      "git submodule foreach --quiet 'git -C $toplevel/$path ls-files --others --ignored --exclude-standard --directory --no-empty-directory | (while read line; do echo $path/$line; done)'",
-    ],
-  ];
-
-  for command in commands {
-    let output = Command::new(&command[0])
-      .args(&command[1..])
-      .current_dir(workspace_root_path)
-      .output()?;
-
-    if output.status.success() {
-      let files = String::from_utf8(output.stdout)?
-        .lines()
-        .filter(|line| !line.is_empty())
-        .map(|line| {
-          let line = line.replace("/", MAIN_SEPARATOR_STR);
-
-          if should_return_absolute_paths {
-            let mut path = std::path::PathBuf::from(workspace_root_path);
-
-            path.push(line.clone());
-
-            match path.canonicalize() {
-              Ok(canonical_path) => {
-                canonical_path.to_string_lossy().into_owned()
-              }
-              Err(_) => String::from(line),
-            }
-          } else {
-            String::from(line)
-          }
-        })
-        .collect::<HashSet<_>>();
-
-      gitignored_files.extend(files);
-    }
-  }
-
-  Ok(gitignored_files)
-}
-
-pub fn list_ignored_files_with_absolute_paths(
-  workspace_root_path: &str,
-) -> Result<HashSet<String>, Box<dyn std::error::Error>> {
-  let mut gitignored_files = HashSet::new();
-
-  let commands = vec![
-    vec![
-      "git",
-      "ls-files",
-      "--others",
-      "--ignored",
-      "--exclude-standard",
-    ],
-    // FIXME(sualeh): this is super sketchy and might totally break in like a bazillion ways. i dont like it.
-    vec![
-      "sh",
-      "-c",
-      "git submodule foreach --quiet 'git ls-files --others --ignored --exclude-standard | sed \"s|^|$path/|\"'",
-    ],
-  ];
-
-  for command in commands {
-    let output = Command::new(&command[0])
-      .args(&command[1..])
-      .current_dir(workspace_root_path)
-      .output()?;
-
-    if output.status.success() {
-      let files = String::from_utf8(output.stdout)?
-        .lines()
-        .filter(|line| !line.is_empty())
-        .map(|line| String::from(line))
-        .collect::<HashSet<_>>();
-
-      gitignored_files.extend(files);
-    }
-  }
-
-  Ok(gitignored_files)
-}
-
-pub async fn is_git_ignored(
-  workspace_root_path: &str,
-  file_path: &str,
-) -> Result<bool, anyhow::Error> {
-  let output = tokio::process::Command::new("git")
-    .args(&["check-ignore", file_path])
-    .current_dir(workspace_root_path)
-    .output()
-    .await?;
-
-  Ok(output.status.success())
-}
-
-pub async fn is_git_directory(
-  workspace_root_path: &str,
-) -> Result<bool, anyhow::Error> {
-  let output = tokio::process::Command::new("git")
-    .args(&["rev-parse", "--is-inside-work-tree"])
-    .current_dir(workspace_root_path)
-    .output()
-    .await?;
-
-  Ok(output.status.success())
-}
-
-#[cfg(test)]
-mod tests {
-  use super::*;
-  use std::fs::File;
-  use std::io::Write;
-
-  #[test]
-  fn test_no_ignored_files() {
-    let dir = tempfile::tempdir().unwrap();
-    let gitignored_files =
-      list_ignored_files_and_directories(dir.path().to_str().unwrap(), false)
-        .unwrap();
-    Command::new("git")
-      .args(&["init"])
-      .current_dir(dir.path())
-      .output()
-      .unwrap();
-    assert_eq!(gitignored_files.len(), 0);
-  }
-
-  #[test]
-  fn test_one_ignored_file() {
-    let dir = tempfile::tempdir().unwrap();
-    println!("tempdir: {:?}", dir);
-    let file_path = dir.path().join("ignored.txt");
-    let mut file = File::create(&file_path).unwrap();
-    writeln!(file, "This is an ignored file.").unwrap();
-
-    let gitignore_path = dir.path().join(".gitignore");
-    let mut gitignore = File::create(&gitignore_path).unwrap();
-    writeln!(gitignore, "ignored.txt").unwrap();
-
-    Command::new("git")
-      .args(&["init"])
-      .current_dir(dir.path())
-      .output()
-      .unwrap();
-    let gitignored_files =
-      list_ignored_files_and_directories(dir.path().to_str().unwrap(), false)
-        .unwrap();
-    println!(
-      "ignored files for test_one_ignored_file: {:?}",
-      gitignored_files
-    );
-    // assert_eq!(gitignored_files.len(), 1);
-    assert!(gitignored_files.contains(&String::from("ignored.txt")));
-  }
-
-  #[test]
-  fn test_multiple_ignored_files() {
-    let dir = tempfile::tempdir().unwrap();
-    println!("tempdir: {:?}", dir);
-    let file_path1 = dir.path().join("ignored1.txt");
-    let file_path2 = dir.path().join("ignored2.txt");
-    let mut file1 = File::create(&file_path1).unwrap();
-    let mut file2 = File::create(&file_path2).unwrap();
-    writeln!(file1, "This is an ignored file.").unwrap();
-    writeln!(file2, "This is another ignored file.").unwrap();
-
-    let gitignore_path = dir.path().join(".gitignore");
-    let mut gitignore = File::create(&gitignore_path).unwrap();
-    writeln!(gitignore, "*.txt").unwrap();
-
-    Command::new("git")
-      .args(&["init"])
-      .current_dir(dir.path())
-      .output()
-      .unwrap();
-    let gitignored_files =
-      list_ignored_files_and_directories(dir.path().to_str().unwrap(), false)
-        .unwrap();
-    println!(
-      "ignored files for test_multiple_ignored_files: {:?}",
-      gitignored_files
-    );
-    // assert_eq!(gitignored_files.len(), 2);
-    assert!(gitignored_files.contains(&String::from("ignored1.txt")));
-    assert!(gitignored_files.contains(&String::from("ignored2.txt")));
-  }
-
-  #[test]
-  fn test_git_submodule_ignored_files() {
-    let dir = tempfile::tempdir().unwrap();
-    let submodule_path = dir.path().join("submodule");
-    std::fs::create_dir(&submodule_path).unwrap();
-
-    let o = Command::new("git")
-      .args(&["init"])
-      .current_dir(&submodule_path)
-      .output()
-      .unwrap();
-    println!("git init output: {:?}", o);
-
-    let file_path = submodule_path.join("ignored.txt");
-    let mut file = File::create(&file_path).unwrap();
-    writeln!(file, "This is an ignored file.").unwrap();
-
-    let file2 = submodule_path.join("ignored2.txt");
-    let mut file = File::create(&file2).unwrap();
-    writeln!(file, "This is another ignored file.").unwrap();
-
-    let gitignore_path = submodule_path.join(".gitignore");
-    let mut gitignore = File::create(&gitignore_path).unwrap();
-    writeln!(gitignore, "*.txt").unwrap();
-
-    let o = Command::new("git")
-      .args(&["init"])
-      .current_dir(dir.path())
-      .output()
-      .unwrap();
-    println!("git init output: {:?}", o);
-
-    // make a commit in the submodule
-    let o = Command::new("git")
-      .args(&["add", "."])
-      .current_dir(&submodule_path)
-      .output()
-      .unwrap();
-    println!("git add output: {:?}", o);
-    let o = Command::new("git")
-      .args(&["commit", "-m", "initial commit"])
-      .current_dir(&submodule_path)
-      .output()
-      .unwrap();
-    println!("git commit output: {:?}", o);
-
-    let o = Command::new("git")
-      .args(&["submodule", "add", "./submodule"])
-      .current_dir(dir.path())
-      .output()
-      .unwrap();
-    println!("git submodule add output: {:?}", o);
-
-    let gitignored_files =
-      list_ignored_files_and_directories(dir.path().to_str().unwrap(), false)
-        .unwrap();
-    println!(
-      "ignored files for test_git_submodule_ignored_files: {:?}",
-      gitignored_files
-    );
-    assert!(gitignored_files.contains(&String::from("submodule/ignored.txt")));
-    assert!(gitignored_files.contains(&String::from("submodule/ignored2.txt")));
-  }
-
-  #[test]
-  fn test_multiple_ignored_files_in_current_dir() {
-    let gitignored_files =
-      list_ignored_files_and_directories(".", false).unwrap();
-    assert!(gitignored_files.len() > 1);
-
-    // print a sample of the ignored files
-    let mut count = 0;
-    for file in gitignored_files {
-      println!("ignored file: {:?}", file);
-      count += 1;
-      if count > 10 {
-        break;
-      }
-    }
-  }
-
-  #[tokio::test]
-  async fn test_file_not_ignored() {
-    let dir = tempfile::tempdir().unwrap();
-    let file_path = dir.path().join("not_ignored.txt");
-    let mut file = File::create(&file_path).unwrap();
-    writeln!(file, "This is not an ignored file.").unwrap();
-
-    Command::new("git")
-      .args(&["init"])
-      .current_dir(dir.path())
-      .output()
-      .unwrap();
-    let is_ignored =
-      is_git_ignored(dir.path().to_str().unwrap(), "not_ignored.txt")
-        .await
-        .unwrap();
-    assert_eq!(is_ignored, false);
-  }
-
-  #[tokio::test]
-  async fn test_file_ignored() {
-    let dir = tempfile::tempdir().unwrap();
-    let file_path = dir.path().join("ignored.txt");
-    let mut file = File::create(&file_path).unwrap();
-    writeln!(file, "This is an ignored file.").unwrap();
-
-    let gitignore_path = dir.path().join(".gitignore");
-    let mut gitignore = File::create(&gitignore_path).unwrap();
-    writeln!(gitignore, "ignored.txt").unwrap();
-
-    Command::new("git")
-      .args(&["init"])
-      .current_dir(dir.path())
-      .output()
-      .unwrap();
-    let is_ignored =
-      is_git_ignored(dir.path().to_str().unwrap(), "ignored.txt")
-        .await
-        .unwrap();
-    assert_eq!(is_ignored, true);
-  }
-
-  #[tokio::test]
-  async fn test_file_ignored_with_wildcard() {
-    let dir = tempfile::tempdir().unwrap();
-    let file_path = dir.path().join("ignored.txt");
-    let mut file = File::create(&file_path).unwrap();
-    writeln!(file, "This is an ignored file.").unwrap();
-
-    let gitignore_path = dir.path().join(".gitignore");
-    let mut gitignore = File::create(&gitignore_path).unwrap();
-    writeln!(gitignore, "*.txt").unwrap();
-
-    Command::new("git")
-      .args(&["init"])
-      .current_dir(dir.path())
-      .output()
-      .unwrap();
-    let is_ignored =
-      is_git_ignored(dir.path().to_str().unwrap(), "ignored.txt")
-        .await
-        .unwrap();
-    assert_eq!(is_ignored, true);
-  }
-}

package/src/lib.rs

@@ -1,300 +0,0 @@
-#![windows_subsystem = "windows"]
-#![deny(clippy::all)]
-#![deny(unsafe_op_in_unsafe_fn)]
-pub mod file_utils;
-pub mod logger;
-pub mod merkle_tree;
-
-use std::{collections::HashSet, vec};
-
-use anyhow::Context;
-use merkle_tree::{LocalConstruction, MerkleTree};
-use tracing::{debug, info};
-
-#[macro_use]
-extern crate napi_derive;
-
-#[napi]
-pub struct MerkleClient {
-  tree: MerkleTree,
-  absolute_root_directory: String,
-  _guard: Option<logger::GuardType>,
-}
-
-#[napi]
-impl MerkleClient {
-  #[napi(constructor)]
-  pub fn new(absolute_root_directory: String) -> MerkleClient {
-    let _guard = logger::init_logger();
-
-    // let canonical_root_directory = std::path::Path::new(&absolute_root_directory);
-    // use dunce::canonicalize;
-    // let canonical_root_directory = match dunce::canonicalize(&canonical_root_directory) {
-    //   Ok(path) => path.to_str().unwrap_or(&absolute_root_directory).to_string().to_lowercase(),
-    //   Err(e) => {
-    //     info!("Error in canonicalizing path: path: {:?}, error {:?}", canonical_root_directory, e);
-    //     absolute_root_directory
-    //   }
-    // };
-
-    MerkleClient {
-      tree: MerkleTree::empty_tree(),
-      absolute_root_directory,
-      _guard,
-    }
-  }
-
-  #[napi]
-  pub async unsafe fn init(
-    &mut self,
-    git_ignored_files: Vec<String>,
-    is_git_repo: bool,
-  ) -> Result<(), napi::Error> {
-    // 1. compute the merkle tree
-    // 2. update the backend
-    // 3. sync with the remote
-    info!("Merkle tree compute started!");
-    info!("Root directory: {:?}", self.absolute_root_directory);
-    unsafe {
-      self
-        .compute_merkle_tree(git_ignored_files, is_git_repo)
-        .await?;
-    }
-
-    Ok(())
-  }
-
-  pub async unsafe fn interrupt(&mut self) -> Result<(), napi::Error> {
-    unimplemented!("Interrupt is not implemented yet");
-  }
-
-  #[napi]
-  pub async unsafe fn compute_merkle_tree(
-    &mut self,
-    git_ignored_files: Vec<String>,
-    is_git_repo: bool,
-  ) -> Result<(), napi::Error> {
-    // make the git ignored files into a hash set
-    let mut git_ignored_set = HashSet::from_iter(git_ignored_files.into_iter());
-
-    // if the hashset itself contains the root directory, then we should remove it.
-    // this is because the root directory is not a file, and we don't want to ignore it.
-    if git_ignored_set.contains(&self.absolute_root_directory) {
-      git_ignored_set.remove(&self.absolute_root_directory);
-    }
-
-    let t = MerkleTree::construct_merkle_tree(
-      self.absolute_root_directory.clone(),
-      git_ignored_set,
-      is_git_repo,
-    )
-    .await;
-
-    match t {
-      Ok(tree) => {
-        self.tree = tree;
-        Ok(())
-      }
-      Err(e) => Err(napi::Error::new(
-        napi::Status::Unknown,
-        format!("Error in compute_merkle_tree: {:?}", e),
-      )),
-    }
-  }
-
-  #[napi]
-  pub async unsafe fn update_file(&mut self, file_path: String) {
-    let _ = self.tree.update_file(file_path).await;
-  }
-
-  #[napi]
-  pub async unsafe fn delete_file(&mut self, file_path: String) {
-    let _r = self.tree.delete_file(file_path);
-  }
-
-  #[napi]
-  pub async fn get_subtree_hash(
-    &self,
-    relative_path: String,
-  ) -> Result<String, napi::Error> {
-    debug!("get_subtree_hash: relative_path: {:?}", relative_path);
-
-    let relative_path_without_leading_slash = match relative_path
-      .strip_prefix('.')
-    {
-      Some(path) => path.strip_prefix(std::path::MAIN_SEPARATOR).unwrap_or(""),
-      None => relative_path.as_str(),
-    };
-    debug!(
-      "relative_path_without_leading_slash: {:?}",
-      relative_path_without_leading_slash
-    );
-
-    let absolute_path = if !relative_path_without_leading_slash.is_empty() {
-      std::path::Path::new(&self.absolute_root_directory)
-        .join(relative_path_without_leading_slash)
-    } else {
-      std::path::Path::new(&self.absolute_root_directory).to_path_buf()
-    };
-
-    debug!("absolute_path: {:?}", absolute_path);
-
-    let absolute_path_string = match absolute_path.to_str() {
-      Some(path) => path.to_string(),
-      None => {
-        return Err(napi::Error::new(
-          napi::Status::Unknown,
-          format!("some string error"),
-        ))
-      }
-    };
-
-    debug!("absolute_path_string: {:?}", absolute_path_string);
-
-    let hash = self
-      .tree
-      .get_subtree_hash(absolute_path_string.as_str())
-      .await;
-
-    match hash {
-      Ok(hash) => Ok(hash),
-      Err(e) => Err(napi::Error::new(
-        napi::Status::Unknown,
-        format!("Error in get_subtree_hash. \nRelative path: {:?}, \nAbsolute path: {:?}, \nRoot directory: {:?}\nError: {:?}", &relative_path, absolute_path, self.absolute_root_directory, e)
-      )),
-    }
-  }
-
-  #[napi]
-  pub async fn get_num_embeddable_files(&self) -> Result<i32, napi::Error> {
-    let num = self.tree.get_num_embeddable_files().await;
-
-    match num {
-      Ok(num) => Ok(num),
-      Err(e) => Err(napi::Error::new(
-        napi::Status::Unknown,
-        format!("Error in get_num_embeddable_files: {:?}", e),
-      )),
-    }
-  }
-
-  pub async fn get_num_embeddable_files_in_subtree(
-    &self,
-    relative_path: String,
-  ) -> Result<i32, napi::Error> {
-    let absolute_path = std::path::Path::new(&self.absolute_root_directory)
-      .join(relative_path)
-      .canonicalize()?;
-
-    let num = self
-      .tree
-      .get_num_embeddable_files_in_subtree(absolute_path)
-      .await;
-
-    match num {
-      Ok(num) => Ok(num),
-      Err(e) => Err(napi::Error::new(
-        napi::Status::Unknown,
-        format!("Error in get_num_embeddable_files_in_subtree: {:?}", e),
-      )),
-    }
-  }
-
-  #[napi]
-  pub async fn get_all_files(&self) -> Result<Vec<String>, napi::Error> {
-    let files = self.tree.get_all_files().await;
-
-    match files {
-      Ok(files) => Ok(files),
-      Err(e) => Err(napi::Error::new(
-        napi::Status::Unknown,
-        format!("Error in get_all_files: {:?}", e),
-      )),
-    }
-  }
-
-  #[napi]
-  pub async fn get_all_dir_files_to_embed(
-    &self,
-    absolute_file_path: String,
-  ) -> Result<Vec<String>, napi::Error> {
-    // let absolute_path = absolute_file_path.to_lowercase();
-    // let absolute_path_str = absolute_path.as_str();
-
-    let files = self
-      .tree
-      .get_all_dir_files_to_embed(absolute_file_path.as_str())
-      .await;
-
-    match files {
-      Ok(files) => Ok(files),
-      Err(e) => Err(napi::Error::new(
-        napi::Status::Unknown,
-        format!("Error in get_all_dir_files_to_embed: {:?}", e),
-      )),
-    }
-  }
-
-  #[napi]
-  pub async unsafe fn get_next_file_to_embed(
-    &mut self,
-  ) -> Result<Vec<String>, napi::Error> {
-    let n = self.tree.get_next_file_to_embed().await;
-
-    match n {
-      Ok((file, path)) => {
-        // now our job is to put the filename as the first element of the path.
-
-        // TODO(sualeh): we should assert that the path is ascending up to the path.
-
-        let ret = vec![file];
-        let ret = ret.into_iter().chain(path.into_iter()).collect::<Vec<_>>();
-        Ok(ret)
-      }
-      Err(e) => Err(napi::Error::new(
-        napi::Status::Unknown,
-        format!("Error in get_next_file_to_embed: {:?}", e),
-      )),
-    }
-  }
-
-  // FIXME(sualeh): get_spline
-  #[napi]
-  pub async fn get_spline(
-    &self,
-    absolute_file_path: String,
-  ) -> Result<Vec<String>, napi::Error> {
-    // let absolute_path = absolute_file_path.to_lowercase();
-    // let absolute_path_str = absolute_path.as_str();
-    let spline = self.tree.get_spline(absolute_file_path.as_str()).await;
-
-    match spline {
-      Ok(spline) => Ok(spline),
-      Err(e) => Err(napi::Error::new(
-        napi::Status::Unknown,
-        format!("Error in get_spline: {:?}", e),
-      )),
-    }
-  }
-
-  #[napi]
-  pub async fn get_hashes_for_files(
-    &self,
-    files: Vec<String>,
-  ) -> Result<Vec<String>, napi::Error> {
-    let hashes = self.tree.get_hashes_for_files(files).await;
-
-    match hashes {
-      Ok(hashes) => Ok(hashes),
-      Err(e) => Err(napi::Error::new(
-        napi::Status::Unknown,
-        format!("Error in get_hashes_for_files: {:?}", e),
-      )),
-    }
-  }
-
-  #[napi]
-  pub fn update_root_directory(&mut self, root_directory: String) {
-    self.absolute_root_directory = root_directory;
-  }
-}