@anysphere/file-service 0.0.0-e3fdf62d → 0.0.0-e492c95a

package/src/git_utils.rs

@@ -1,207 +0,0 @@
-use std::collections::HashSet;
-use std::path::PathBuf;
-use std::process::Command;
-
-pub fn list_ignored_files(
-  workspace_root_path: &str,
-) -> Result<HashSet<PathBuf>, Box<dyn std::error::Error>> {
-  let mut gitignored_files = HashSet::new();
-
-  let commands = vec![
-    vec![
-      "git",
-      "ls-files",
-      "--others",
-      "--ignored",
-      "--exclude-standard",
-    ],
-    vec![
-      "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| PathBuf::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())
-}
-
-#[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(dir.path().to_str().unwrap()).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(dir.path().to_str().unwrap()).unwrap();
-    println!(
-      "ignored files for test_one_ignored_file: {:?}",
-      gitignored_files
-    );
-    // assert_eq!(gitignored_files.len(), 1);
-    assert!(gitignored_files.contains(&PathBuf::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(dir.path().to_str().unwrap()).unwrap();
-    println!(
-      "ignored files for test_multiple_ignored_files: {:?}",
-      gitignored_files
-    );
-    // assert_eq!(gitignored_files.len(), 2);
-    assert!(gitignored_files.contains(&PathBuf::from("ignored1.txt")));
-    assert!(gitignored_files.contains(&PathBuf::from("ignored2.txt")));
-  }
-
-  #[test]
-  fn test_multiple_ignored_files_in_current_dir() {
-    let gitignored_files = list_ignored_files(".").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,158 +0,0 @@
-#![deny(clippy::all)]
-pub mod file_utils;
-pub mod git_utils;
-pub mod merkle_tree;
-
-use std::vec;
-
-use merkle_tree::{LocalConstruction, MerkleTree};
-
-#[macro_use]
-extern crate napi_derive;
-
-#[napi]
-pub struct MerkleClient {
-  tree: MerkleTree,
-  root_directory: String,
-}
-
-#[napi]
-impl MerkleClient {
-  #[napi(constructor)]
-  pub fn new(root_directory: String) -> MerkleClient {
-    MerkleClient {
-      tree: MerkleTree::empty_tree(),
-      root_directory,
-    }
-  }
-
-  #[napi]
-  pub async unsafe fn init(&mut self) -> Result<(), napi::Error> {
-    // 1. compute the merkle tree
-    // 2. update the backend
-    // 3. sync with the remote
-    self.compute_merkle_tree().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,
-  ) -> Result<(), napi::Error> {
-    let t =
-      MerkleTree::construct_merkle_tree(self.root_directory.clone()).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,
-    path: String,
-  ) -> Result<String, napi::Error> {
-    let hash = self.tree.get_subtree_hash(path).await;
-
-    match hash {
-      Ok(hash) => Ok(hash),
-      Err(e) => Err(napi::Error::new(
-        napi::Status::Unknown,
-        format!("Error in get_subtree_hash: {:?}", 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),
-      )),
-    }
-  }
-
-  #[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 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),
-      )),
-    }
-  }
-
-  #[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.root_directory = root_directory;
-  }
-}

package/src/lib2.rs

@@ -1,212 +0,0 @@
-#![deny(clippy::all)]
-pub mod file_utils;
-pub mod git_utils;
-pub mod merkle_tree;
-
-// #[path = "proto/aiserver.v1.rs"]
-// pub mod aiserver;
-
-// use aiserver::repository_service_client::RepositoryServiceClient;
-// use aiserver::{FastRepoInitHandshakeRequest, GetNumFilesToSendRequest, GetNumFilesToSendResponse};
-use merkle_tree::{MerkleTree, LocalConstruction};
-
-// use tonic::metadata::MetadataValue;
-// use tonic::transport::Channel;
-// use tonic::Request;
-// use aiserver::v1::repository_client::RepositoryClient;
-
-#[macro_use]
-extern crate napi_derive;
-
-// pub type RepositoryClient = RepositoryServiceClient<
-//   tonic::service::interceptor::InterceptedService<Channel, AsphrAuthInterceptor>,
-// >;
-
-#[napi]
-pub struct MerkleClient {
-  tree: MerkleTree,
-  root_directory: String,
-  // intercepter: AsphrAuthInterceptor,
-  // backend_url: String,
-  // repository_info: RepositoryInfo,
-  // repo_client: Option<RepositoryClient>,
-}
-
-
-#[napi]
-impl MerkleClient {
-  #[napi(constructor)]
-  pub fn new(
-		root_directory: String,
-		// bearer_token: String,
-		// backend_url: String,
-		// repository_info: RepositoryInfo
-	) -> MerkleClient {
-    MerkleClient {
-      tree: MerkleTree::empty_tree(),
-      root_directory,
-      // intercepter: AsphrAuthInterceptor::new(bearer_token),
-      // backend_url,
-			// repository_info,
-    }
-  }
-
-  #[napi]
-  pub async unsafe fn init(&mut self) -> Result<(), napi::Error> {
-    // 1. compute the merkle tree
-    // 2. update the backend
-    // 3. sync with the remote
-    self.compute_merkle_tree().await;
-    let res = self.sync_with_remote().await;
-
-    if let Err(e) = res {
-      println!("Error: {:?}", e);
-      return Err(napi::Error::new(
-        napi::Status::Unknown,
-        "Error in sync_with_remote",
-      ));
-    }
-
-    Ok(())
-  }
-
-	// #[napi]
-	pub async unsafe fn interrupt(&mut self) -> Result<(), napi::Error> {
-		unimplemented!("Interrupt is not implemented yet");
-	}
-
-  // pub async fn update_backend(&self) -> Result<RepositoryClient, napi::Error> {
-  //   let channel = match Channel::from_shared(self.backend_url.clone()) {
-  //     Ok(channel) => {
-  //       let connection = match channel.connect().await {
-  //         Ok(connection) => connection,
-  //         Err(_) => {
-  //           return Err(napi::Error::new(
-  //             napi::Status::Unknown,
-  //             "Invalid backend URL",
-  //           ))
-  //         }
-  //       };
-
-  //       connection
-  //     }
-  //     Err(_) => {
-  //       return Err(napi::Error::new(
-  //         napi::Status::Unknown,
-  //         "Invalid backend URL",
-  //       ))
-  //     }
-  //   };
-
-  //   let repo_client = RepositoryServiceClient::with_interceptor(channel, self.intercepter.clone());
-
-  //   Ok(repo_client)
-  // }
-
-  // #[napi]
-  pub async fn sync_with_remote(&self) -> Result<(), napi::Error> {
-    // BLOCKER:
-    // 1. need to get the repository info nicely from javascript.
-    // 2. need to handle the napi conversions.
-    // let client: Result<RepositoryClient, napi::Error> = self.update_backend().await;
-
-    // if let Err(e) = client {
-    //   return Err(e);
-    // }
-    // let mut client = client.unwrap();
-
-    // 1. make sure your tree is upto date.
-    // just make sure that you did an update recently and that you havent left too many updates to be buffered up.
-
-    // 2. sync it carefully.
-    // let repo_init_handshake_req = tonic::Request::new(FastRepoInitHandshakeRequest {
-    // 	repository:
-    // 	merkle_tree: self.tree.clone(),
-    // });
-    // client.fast_repo_init_handshake()
-
-    // 2.5 if the hash is the same, you are happy and you just leave.
-
-    // 3. start the diffing process if everything is ok.
-    // let different_files = self.tree.sync_with_remote(client).await;
-    // let num_files_to_send = different_files.len();
-
-    // 4. send those files to the server!
-    Ok(())
-  }
-
-	#[napi]
-  pub async unsafe fn compute_merkle_tree(&mut self) {
-    self.tree = MerkleTree::construct_merkle_tree(self.root_directory.clone()).await;
-  }
-
-  #[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 fn update_root_directory(&mut self, root_directory: String) {
-    self.root_directory = root_directory;
-  }
-
-  // TODO
-  // pub fn update_repository_info(&mut self, repository_info: RepositoryInfo) {
-  //   self.repository_info = repository_info;
-  // }
-}
-
-#[napi(object)]
-#[derive(Clone, Debug)]
-pub struct RepositoryInfo {
-	pub relative_workspace_path: String,
-	pub remote_urls: String,
-	pub remote_names: String,
-	pub repo_name: String,
-	pub repo_owner: String,
-	pub is_tracked: bool,
-	pub is_local: bool,
-	pub num_files: Option<i32>
-}
-
-
-// use std::convert::TryFrom;
-// A simple implementation of an interceptor that adds a bearer token to the request
-// #[derive(Clone)]
-// pub struct AsphrAuthInterceptor {
-//   auth_token: String,
-//   full_auth_string: String,
-// }
-
-// impl tonic::service::Interceptor for AsphrAuthInterceptor {
-//   fn call(&mut self, mut request: tonic::Request<()>) -> Result<tonic::Request<()>, tonic::Status> {
-//     request.metadata_mut().insert(
-//       "authorization",
-//       MetadataValue::try_from(&self.full_auth_string).unwrap(),
-//     );
-//     Ok(request)
-//   }
-// }
-
-// impl AsphrAuthInterceptor {
-//   pub fn new(auth_token: String) -> AsphrAuthInterceptor {
-//     AsphrAuthInterceptor {
-//       auth_token: auth_token.clone(),
-//       full_auth_string: format!("Bearer {}", auth_token),
-//     }
-//   }
-
-//   pub fn get_auth_token(&self) -> String {
-//     self.auth_token.clone()
-//   }
-
-//   pub fn update_auth_token(&mut self, new_token: String) {
-//     self.auth_token = new_token;
-//     self.full_auth_string = format!("Bearer {}", self.auth_token);
-//   }
-// }