chore: use anyhow + resolve lint errors

Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+anyhow = "1.0.82"
 clap = "4.5.1"
 data-encoding = "2.5.0"
 dirs = "5.0.1"

src/cache.rs

@@ -1,9 +1,10 @@
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
+use anyhow::Result;
 use serde::{Deserialize, Serialize};
 
-use crate::core::{Result, APP_NAME};
+use crate::core::APP_NAME;
 use crate::errors::{to_error, Error, Paths};
 use crate::utils::path::{to_dir_key, DirKey};
 use crate::utils::{fs, hash::Hash};
@@ -37,7 +38,7 @@ impl Metadata {
           contents,
           file_path: file_path.clone(),
         })
-        .map_err(|error| Error::Parse(Paths::One(file_path), error.to_string())),
+        .map_err(|error| Error::Parse(Paths::One(file_path), error.to_string()).into()),
       Err(_) => {
         let v = Self {
           file_path: file_path.clone(),
@@ -161,13 +162,13 @@ impl Cache {
         }
         // escape the current cache is exists
         fs::rename(&self.target_dir, self.to_cache_path(&current_hash_key))
-          .map_err(|error| error.log_warn(Some("Failed to save the old cache")))
+          .map_err(|error| error.context("Failed to save the old cache"))
           .unwrap_or(());
       }
       // restore the cache
       fs::rename(cache, &self.target_dir).and(Ok(self.clone()))
     } else {
-      Err(Error::NotDir(cache))
+      Err(Error::NotDir(cache).into())
     }
   }
 }

src/core.rs

@@ -1,11 +1,9 @@
-use std::{
-  path::{Path, PathBuf},
-  result,
-};
+use std::path::{Path, PathBuf};
+
+use anyhow::Result;
 
 use crate::{
   cache::Cache,
-  errors::Error,
   lockfile::Lockfile,
   package_manager::PackageManager,
   project::ProjectRoot,
@@ -15,8 +13,6 @@ use crate::{
   },
 };
 
-pub type Result<T> = result::Result<T, Error>;
-
 pub const APP_NAME: &str = "syncnm";
 
 pub fn run(base_dir: impl AsRef<Path>, cache_dir: Option<impl AsRef<Path>>) -> Result<()> {
@@ -30,14 +26,10 @@ pub fn run(base_dir: impl AsRef<Path>, cache_dir: Option<impl AsRef<Path>>) -> R
   if let Ok(lockfile) = &lockfile {
     let cache = Cache::new(&base_dir, &node_modules_dir, cache_dir.as_ref());
     let cache_hash_key = generate_cache_key(&base_dir, lockfile, &project_root);
-    match (cache.as_ref(), cache_hash_key) {
-      (Ok(cache), Ok(cache_hash_key)) => {
-        match cache.restore(&base_dir, &cache_hash_key) {
-          Ok(_) => return Ok(()),
-          _ => {}
-        };
+    if let (Ok(cache), Ok(cache_hash_key)) = (cache.as_ref(), cache_hash_key) {
+      if cache.restore(&base_dir, &cache_hash_key).is_ok() {
+        return Ok(());
       }
-      _ => {}
     }
     if let Ok(cache) = &cache {
       // save the current cache before update node_modules and a lockfile

src/errors.rs

@@ -148,6 +148,6 @@ fn stringify_install_command(package_manager: &PackageManager) -> String {
   )
 }
 
-pub fn to_error<E: Debug>(error: E) -> Error {
-  Error::Any(format!("{:?}", error))
+pub fn to_error<E: Debug>(error: E) -> anyhow::Error {
+  Error::Any(format!("{:?}", error)).into()
 }

src/lockfile.rs

@@ -4,11 +4,11 @@ use std::{
   path::{Path, PathBuf},
 };
 
+use anyhow::Result;
 use itertools::Itertools;
 use strum::IntoEnumIterator;
 
 use crate::{
-  core::Result,
   errors::{to_error, Error},
   package_manager::PackageManagerKind,
   utils::{hash::Hashable, option::both_and_then},
@@ -47,7 +47,7 @@ impl Lockfile {
         .iter()
         .next()
         .map(|(kind, path)| (*kind, path.clone()))
-        .ok_or(Error::NoLockfile(base_dir)),
+        .ok_or(Error::NoLockfile(base_dir).into()),
       2 =>
       // priority to Bun if lockfiles for Bun and Yarn coexist
       // Bun has a option to generate yarn.lock (v1) as said in https://bun.sh/docs/install/lockfile
@@ -57,15 +57,13 @@ impl Lockfile {
           kinds.contains_key(&PackageManagerKind::Yarn).then_some(()),
         )
         .map(|((kind, path), _)| (*kind, path.clone()))
-        .ok_or(Error::MultipleLockfiles(
-          base_dir,
-          kinds.into_values().sorted().collect_vec(),
-        ))
+        .ok_or(
+          Error::MultipleLockfiles(base_dir, kinds.into_values().sorted().collect_vec()).into(),
+        )
+      }
+      _ => {
+        Err(Error::MultipleLockfiles(base_dir, kinds.into_values().sorted().collect_vec()).into())
       }
-      _ => Err(Error::MultipleLockfiles(
-        base_dir,
-        kinds.into_values().sorted().collect_vec(),
-      )),
     }
   }
 }
@@ -127,19 +125,20 @@ mod tests {
   );
 
   #[test]
-  fn test_new_nope() {
+  fn test_new_nope() -> Result<()> {
     let lockfile = Lockfile::new("tests/fixtures/lockfile/nope");
     assert_eq!(
-      lockfile.unwrap_err(),
+      lockfile.unwrap_err().downcast::<Error>()?,
       Error::NoLockfile(PathBuf::from("tests/fixtures/lockfile/nope"))
     );
+    Ok(())
   }
 
   #[test]
   fn test_new_multiple() {
     let lockfile = Lockfile::new("tests/fixtures/lockfile/multiple");
     assert_eq!(
-      lockfile.unwrap_err(),
+      lockfile.unwrap_err().downcast::<Error>().unwrap(),
       Error::MultipleLockfiles(
         PathBuf::from("tests/fixtures/lockfile/multiple"),
         [

src/package_manager.rs

@@ -1,9 +1,10 @@
 use std::{path::Path, process::Command, vec};
 
+use anyhow::Result;
 use serde::{Deserialize, Serialize};
 use strum_macros::EnumIter;
 
-use crate::{core::Result, errors::Error};
+use crate::errors::Error;
 
 #[derive(Debug, PartialEq, Clone)]
 pub struct PackageManager {
@@ -49,8 +50,9 @@ impl PackageManager {
 
   pub fn execute_install(self, base_dir: impl AsRef<Path>) -> Result<()> {
     let base_dir = base_dir.as_ref().to_path_buf();
-    let to_error =
-      |message: String| Error::FailedToInstallDependencies(self.clone(), base_dir.clone(), message);
+    let to_error = |message: String| {
+      Error::FailedToInstallDependencies(self.clone(), base_dir.clone(), message).into()
+    };
     let output = Command::new(&self.executable_name)
       .arg(&self.install_sub_command)
       .current_dir(&base_dir)

src/project.rs

@@ -5,12 +5,12 @@ use std::{
   path::{Path, PathBuf},
 };
 
+use anyhow::Result;
 use regex::Regex;
 use serde::{Deserialize, Serialize};
 use strum::IntoEnumIterator;
 
 use crate::{
-  core::Result,
   errors::{to_error, Error, Paths},
   package_manager::PackageManagerKind,
   utils::hash::Hashable,
@@ -59,8 +59,8 @@ impl PackageJson {
     let contents = fs::read_to_string(&file_path);
     match contents {
       Ok(contents) => serde_json::from_str::<Self>(&contents)
-        .map_err(|error| Error::Parse(Paths::One(file_path), error.to_string())),
-      Err(_) => Err(Error::NoEntry(Paths::One(file_path))),
+        .map_err(|error| Error::Parse(Paths::One(file_path), error.to_string()).into()),
+      Err(_) => Err(Error::NoEntry(Paths::One(file_path)).into()),
     }
   }
 }
@@ -104,7 +104,7 @@ impl WorkspacePackage {
   fn new(base_dir: impl AsRef<Path>, kind: PackageManagerKind) -> Result<Self> {
     let base_dir = base_dir.as_ref().to_path_buf();
     if !is_valid_base_dir(&base_dir) {
-      return Err(Error::InvalidWorkspace(base_dir));
+      return Err(Error::InvalidWorkspace(base_dir).into());
     }
     let original = PackageJson::new(&base_dir)?;
     Ok(Self {
@@ -121,10 +121,10 @@ impl WorkspacePackage {
       PackageManagerKind::Yarn
         if self.original.name.is_none() || self.original.version.is_none() =>
       {
-        Err(Error::InvalidPackageJsonFieldsForYarn(package_json_path))
+        Err(Error::InvalidPackageJsonFieldsForYarn(package_json_path).into())
       }
       PackageManagerKind::Bun if self.original.name.is_none() => {
-        Err(Error::InvalidPackageJsonFieldsForBun(package_json_path))
+        Err(Error::InvalidPackageJsonFieldsForBun(package_json_path).into())
       }
       _ => Ok(self),
     }
@@ -197,7 +197,7 @@ impl ProjectRoot {
       }
       .validate_package_json_fields(&base_dir)
     } else {
-      Err(Error::NoLockfile(base_dir.as_ref().to_path_buf()))
+      Err(Error::NoLockfile(base_dir.as_ref().to_path_buf()).into())
     }
   }
 
@@ -272,7 +272,9 @@ impl ProjectRoot {
           && !self.original.private.unwrap_or_default() =>
       {
         Err(
-          Error::InvalidPackageJsonPrivateForYarn(to_package_json_path(&base_dir)).log_error(None),
+          Error::InvalidPackageJsonPrivateForYarn(to_package_json_path(&base_dir))
+            .log_error(None)
+            .into(),
         )
       }
       _ => Ok(self),
@@ -434,7 +436,10 @@ mod tests {
       assert_eq!(project_root.root, expected.root);
       assert_eq!(project_root.workspaces, expected.workspaces);
     } else {
-      assert_eq!(project_root.unwrap_err(), case.expected.unwrap_err());
+      assert_eq!(
+        project_root.unwrap_err().downcast::<Error>().unwrap(),
+        case.expected.unwrap_err().downcast::<Error>().unwrap()
+      );
     }
   }
 
@@ -524,7 +529,7 @@ mod tests {
         PathBuf::from("tests/fixtures/workspaces/yarn_private_false"),
         Some(PackageManagerKind::Yarn),
       ),
-      expected:Err(Error::InvalidPackageJsonPrivateForYarn(PathBuf::from("tests/fixtures/workspaces/yarn_private_false/package.json")))
+      expected:Err(Error::InvalidPackageJsonPrivateForYarn(PathBuf::from("tests/fixtures/workspaces/yarn_private_false/package.json")).into())
     },
     "pnpm" => NewTestCase {
       input: (

src/utils/fs.rs

@@ -3,8 +3,9 @@ use std::{
   path::{Path, PathBuf},
 };
 
+use anyhow::Result;
+
 use crate::{
-  core::Result,
   errors::{to_error, Error, Paths},
   utils::path::to_absolute_path,
 };
@@ -16,14 +17,16 @@ pub fn exists_dir(dir: impl AsRef<Path>) -> Result<PathBuf> {
     match &original {
       Ok(original) if original.is_dir() => original
         .canonicalize()
-        .map_err(|_| Error::NotAccessible(dir)),
-      Ok(_) => Err(Error::NotDir(dir)),
-      Err(_) => Err(Error::NotAccessible(dir)),
+        .map_err(|_| Error::NotAccessible(dir).into()),
+      Ok(_) => Err(Error::NotDir(dir).into()),
+      Err(_) => Err(Error::NotAccessible(dir).into()),
     }
   } else if dir.is_dir() {
-    dir.canonicalize().map_err(|_| Error::NotAccessible(dir))
+    dir
+      .canonicalize()
+      .map_err(|_| Error::NotAccessible(dir).into())
   } else {
-    Err(Error::NotDir(dir))
+    Err(Error::NotDir(dir).into())
   }
 }
 
@@ -79,7 +82,7 @@ mod tests {
 
   struct ExistsDirTestCase {
     dir: &'static str,
-    expected: Result<PathBuf>,
+    expected: Result<PathBuf, Error>,
   }
 
   test_each_serial!(
@@ -99,7 +102,7 @@ mod tests {
             expected_original.canonicalize().unwrap()
           )
         },
-        Err(error) => assert_eq!(&result.unwrap_err(), error)
+        Err(error) => assert_eq!(result.unwrap_err().downcast_ref::<Error>().unwrap(), error)
       }
 
     }),
@@ -194,7 +197,7 @@ mod tests {
     });
 
     fs::remove_dir_all(&base_dir).unwrap();
-    assert_eq!(result, Ok(()));
+    assert!(result.is_ok());
   }
 
   // TODO* fix this test for windows
@@ -264,6 +267,6 @@ mod tests {
     });
 
     fs::remove_dir_all(&base_dir).unwrap();
-    assert_eq!(result, Ok(()));
+    assert!(result.is_ok());
   }
 }

src/utils/hash.rs

@@ -1,10 +1,11 @@
 use std::fmt::{Debug, Display};
 
+use anyhow::Result;
 use data_encoding::BASE32_NOPAD;
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
 
-use crate::{core::Result, errors::to_error};
+use crate::errors::to_error;
 
 #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Hash, Clone)]
 pub struct Hash(pub String);
@@ -15,12 +16,6 @@ impl Display for Hash {
   }
 }
 
-impl Hash {
-  pub fn to_string(&self) -> String {
-    self.0.to_string()
-  }
-}
-
 pub trait Hashable {
   fn to_hash_target(&self) -> Result<impl AsRef<[u8]>>;