cli: Use thiserror #[from] instead of derive_more

Plus some other improvements.

Author: NunoAlexandre

cli/src/account_storage.rs

@@ -45,37 +45,36 @@ pub enum Error {
 
     /// Failed to write to the accounts file
     #[error("Failed to write to the accounts file: {0}")]
-    FailedWrite(WritingError),
+    FailedWrite(#[from] WritingError),
 
     /// Failed to read the accounts file
     #[error("Failed to read the accounts file: {0}")]
-    FailedRead(ReadingError),
+    FailedRead(#[from] ReadingError),
 }
 
-
 /// Possible errors when writing to the accounts file.
 #[derive(Debug, ThisError)]
 pub enum WritingError {
-    #[error("{0}")]
+    #[error(transparent)]
     IO(IOError),
 
-    #[error("{0}")]
+    #[error(transparent)]
     Serialization(serde_json::Error),
 }
 
 /// Possible errors when reading the accounts file.
 #[derive(Debug, ThisError)]
 pub enum ReadingError {
-    #[error("{0}")]
+    #[error(transparent)]
     IO(IOError),
 
-    #[error("{0}")]
+    #[error(transparent)]
     Deserialization(serde_json::Error),
 }
 
 /// Add an account to the storage.
 ///
-/// Fails if an account with the given `name` already exists_.
+/// Fails if an account with the given `name` already exists.
 /// It can also fail from IO and Serde Json errors.
 pub fn add(name: String, data: AccountData) -> Result<(), Error> {
     let mut accounts = list()?;
@@ -87,25 +86,22 @@ pub fn add(name: String, data: AccountData) -> Result<(), Error> {
     update(accounts)
 }
 
-/// List all the stored accountsr
+/// List all the stored accounts.
 ///
 /// It can fail from IO and Serde Json errors.
 pub fn list() -> Result<HashMap<String, AccountData>, Error> {
     let path_buf = get_or_create_path()?;
-    let file = File::open(path_buf.as_path())
-        .map_err(|e| Error::FailedRead(ReadingError::IO(e)))?;
+    let file = File::open(path_buf.as_path()).map_err(ReadingError::IO)?;
     let accounts: HashMap<String, AccountData> =
-        serde_json::from_reader(&file)
-            .map_err(|e| Error::FailedRead(ReadingError::Deserialization(e)))?;
+        serde_json::from_reader(&file).map_err(ReadingError::Deserialization)?;
     Ok(accounts)
 }
 
 fn update(accounts: HashMap<String, AccountData>) -> Result<(), Error> {
     let path_buf = get_or_create_path()?;
-    let new_content = serde_json::to_string(&accounts)
-        .map_err(|e| Error::FailedWrite(WritingError::Serialization(e)))?;
-    std::fs::write(path_buf.as_path(), new_content.as_bytes())
-        .map_err(|e| Error::FailedWrite(WritingError::IO(e)))
+    let new_content = serde_json::to_string(&accounts).map_err(WritingError::Serialization)?;
+    std::fs::write(path_buf.as_path(), new_content.as_bytes()).map_err(WritingError::IO)?;
+    Ok(())
 }
 
 const FILE: &str = "accounts.json";
@@ -121,8 +117,7 @@ fn get_or_create_path() -> Result<PathBuf, Error> {
     let path = path_buf.as_path();
 
     if !path.exists() {
-        std::fs::write(path, b"{}")
-            .map_err(|e| Error::FailedWrite(WritingError::IO(e)))?;
+        std::fs::write(path, b"{}").map_err(WritingError::IO)?;
     }
 
     Ok(path_buf)
@@ -133,6 +128,6 @@ fn dir() -> Result<PathBuf, Error> {
         .unwrap()
         .data_dir()
         .join("radicle-registry-cli");
-    std::fs::create_dir_all(&dir).map_err(|e| Error::FailedRead(ReadingError::IO(e)))?;
+    std::fs::create_dir_all(&dir).map_err(ReadingError::IO)?;
     Ok(dir)
 }

cli/src/lib.rs

@@ -119,27 +119,27 @@ pub trait CommandT {
 
 /// Error returned by [CommandT::run].
 ///
-/// Implements [From] for client errors.
-#[derive(Debug, derive_more::From, ThisError)]
+/// Implements [From] for client errors and [account_storage] errors.
+#[derive(Debug, ThisError)]
 pub enum CommandError {
     #[error("Client error: {0}")]
-    ClientError(Error),
+    ClientError(#[from] Error),
 
-    #[error("Transaction {tx_hash:?} failed in block {block_hash:?}")]
+    #[error("Transaction {tx_hash} failed in block {block_hash}")]
     FailedTransaction {
         tx_hash: TxHash,
         block_hash: BlockHash,
     },
 
-    #[error("Cannot find org {org_id:?}")]
+    #[error("Cannot find org {org_id}")]
     OrgNotFound { org_id: OrgId },
 
-    #[error("Cannot find project {project_name:?}.{org_id:?}")]
+    #[error("Cannot find project {project_name}.{org_id}")]
     ProjectNotFound {
         project_name: ProjectName,
         org_id: OrgId,
     },
 
     #[error("{0}")]
-    AccountStorageError(account_storage::Error),
+    AccountStorageError(#[from] account_storage::Error),
 }