Merge pull request #155 from theseus-rs/remove-anyhow-dependency

brianheineman · web-flow · commit 30e71fd982f5 · 2025-01-24T17:00:49.000-07:00
chore: remove anyhow and human_bytes dependencies
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -36,7 +36,6 @@ futures-util = "0.3.30"
 hex = "0.4.3"
 home = "0.5.11"
 http = "1.1.0"
-human_bytes = { version = "0.4.3", default-features = false }
 indicatif = "0.17.8"
 indoc = "2.0.5"
 liblzma = "0.3.4"
diff --git a/postgresql_archive/Cargo.toml b/postgresql_archive/Cargo.toml
@@ -11,13 +11,11 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
 async-trait = { workspace = true }
 flate2 = { workspace = true }
 futures-util = { workspace = true }
 hex = { workspace = true }
 http = { workspace = true }
-human_bytes = { workspace = true, default-features = false }
 liblzma = { workspace = true }
 md-5 = { workspace = true, optional = true }
 num-format = { workspace = true }
@@ -43,6 +41,7 @@ url = { workspace = true }
 zip = { workspace = true }
 
 [dev-dependencies]
+anyhow = { workspace = true }
 criterion = { workspace = true }
 hex = { workspace = true }
 test-log = { workspace = true }
diff --git a/postgresql_archive/src/error.rs b/postgresql_archive/src/error.rs
@@ -17,11 +17,11 @@ pub enum Error {
     #[error("version '{0}' is invalid")]
     InvalidVersion(String),
     /// IO error
-    #[error(transparent)]
-    IoError(anyhow::Error),
+    #[error("{0}")]
+    IoError(String),
     /// Parse error
-    #[error(transparent)]
-    ParseError(anyhow::Error),
+    #[error("{0}")]
+    ParseError(String),
     /// Poisoned lock
     #[error("poisoned lock '{0}'")]
     PoisonedLock(String),
@@ -51,70 +51,63 @@ pub enum Error {
 /// Converts a [`regex::Error`] into an [`ParseError`](Error::ParseError)
 impl From<regex::Error> for Error {
     fn from(error: regex::Error) -> Self {
-        Error::ParseError(error.into())
+        Error::ParseError(error.to_string())
     }
 }
 
 /// Converts a [`reqwest::Error`] into an [`IoError`](Error::IoError)
 impl From<reqwest::Error> for Error {
     fn from(error: reqwest::Error) -> Self {
-        Error::IoError(error.into())
+        Error::IoError(error.to_string())
     }
 }
 
 /// Converts a [`reqwest_middleware::Error`] into an [`IoError`](Error::IoError)
 impl From<reqwest_middleware::Error> for Error {
     fn from(error: reqwest_middleware::Error) -> Self {
-        Error::IoError(error.into())
+        Error::IoError(error.to_string())
     }
 }
 
 /// Converts a [`std::io::Error`] into an [`IoError`](Error::IoError)
 impl From<std::io::Error> for Error {
     fn from(error: std::io::Error) -> Self {
-        Error::IoError(error.into())
+        Error::IoError(error.to_string())
     }
 }
 
 /// Converts a [`std::time::SystemTimeError`] into an [`IoError`](Error::IoError)
 impl From<std::time::SystemTimeError> for Error {
     fn from(error: std::time::SystemTimeError) -> Self {
-        Error::IoError(error.into())
+        Error::IoError(error.to_string())
     }
 }
 
 /// Converts a [`std::num::ParseIntError`] into an [`ParseError`](Error::ParseError)
 impl From<std::num::ParseIntError> for Error {
     fn from(error: std::num::ParseIntError) -> Self {
-        Error::ParseError(error.into())
+        Error::ParseError(error.to_string())
     }
 }
 
 /// Converts a [`semver::Error`] into an [`ParseError`](Error::ParseError)
 impl From<semver::Error> for Error {
     fn from(error: semver::Error) -> Self {
-        Error::IoError(error.into())
+        Error::IoError(error.to_string())
     }
 }
 
 /// Converts a [`std::path::StripPrefixError`] into an [`ParseError`](Error::ParseError)
 impl From<std::path::StripPrefixError> for Error {
     fn from(error: std::path::StripPrefixError) -> Self {
-        Error::ParseError(error.into())
-    }
-}
-
-/// Converts a [`anyhow::Error`] into an [`Unexpected`](Error::Unexpected)
-impl From<anyhow::Error> for Error {
-    fn from(error: anyhow::Error) -> Self {
-        Error::Unexpected(error.to_string())
+        Error::ParseError(error.to_string())
     }
 }
 
 /// Converts a [`url::ParseError`] into an [`ParseError`](Error::ParseError)
 impl From<url::ParseError> for Error {
     fn from(error: url::ParseError) -> Self {
-        Error::ParseError(error.into())
+        Error::ParseError(error.to_string())
     }
 }
 
@@ -200,13 +193,6 @@ mod test {
         );
     }
 
-    #[test]
-    fn test_from_anyhow_error() {
-        let anyhow_error = anyhow::Error::msg("test");
-        let error = Error::from(anyhow_error);
-        assert_eq!(error.to_string(), "test");
-    }
-
     #[test]
     fn test_from_url_parse_error() {
         let parse_error = url::ParseError::EmptyHost;
diff --git a/postgresql_archive/src/extractor/tar_gz_extractor.rs b/postgresql_archive/src/extractor/tar_gz_extractor.rs
@@ -2,7 +2,6 @@ use crate::extractor::ExtractDirectories;
 use crate::Error::Unexpected;
 use crate::Result;
 use flate2::bufread::GzDecoder;
-use human_bytes::human_bytes;
 use num_format::{Locale, ToFormattedString};
 use std::fs::{create_dir_all, File};
 use std::io::{copy, BufReader, Cursor};
@@ -14,7 +13,6 @@ use tracing::{debug, instrument, warn};
 ///
 /// # Errors
 /// Returns an error if the extraction fails.
-#[expect(clippy::cast_precision_loss)]
 #[instrument(skip(bytes))]
 pub fn extract(bytes: &Vec<u8>, extract_directories: ExtractDirectories) -> Result<Vec<PathBuf>> {
     let mut files = Vec::new();
@@ -74,7 +72,7 @@ pub fn extract(bytes: &Vec<u8>, extract_directories: ExtractDirectories) -> Resu
     debug!(
         "Extracted {} files totalling {}",
         number_of_files.to_formatted_string(&Locale::en),
-        human_bytes(extracted_bytes as f64)
+        extracted_bytes,
     );
 
     Ok(files)
diff --git a/postgresql_archive/src/extractor/tar_xz_extractor.rs b/postgresql_archive/src/extractor/tar_xz_extractor.rs
@@ -1,7 +1,6 @@
 use crate::extractor::ExtractDirectories;
 use crate::Error::Unexpected;
 use crate::Result;
-use human_bytes::human_bytes;
 use liblzma::bufread::XzDecoder;
 use num_format::{Locale, ToFormattedString};
 use std::fs::{create_dir_all, File};
@@ -14,7 +13,6 @@ use tracing::{debug, instrument, warn};
 ///
 /// # Errors
 /// Returns an error if the extraction fails.
-#[expect(clippy::cast_precision_loss)]
 #[instrument(skip(bytes))]
 pub fn extract(bytes: &Vec<u8>, extract_directories: ExtractDirectories) -> Result<Vec<PathBuf>> {
     let mut files = Vec::new();
@@ -76,7 +74,7 @@ pub fn extract(bytes: &Vec<u8>, extract_directories: ExtractDirectories) -> Resu
     debug!(
         "Extracted {} files totalling {}",
         number_of_files.to_formatted_string(&Locale::en),
-        human_bytes(extracted_bytes as f64)
+        extracted_bytes,
     );
 
     Ok(files)
diff --git a/postgresql_archive/src/extractor/zip_extractor.rs b/postgresql_archive/src/extractor/zip_extractor.rs
@@ -1,6 +1,5 @@
 use crate::extractor::ExtractDirectories;
 use crate::Result;
-use human_bytes::human_bytes;
 use num_format::{Locale, ToFormattedString};
 use std::fs::create_dir_all;
 use std::io::Cursor;
@@ -13,7 +12,6 @@ use zip::ZipArchive;
 ///
 /// # Errors
 /// Returns an error if the extraction fails.
-#[expect(clippy::cast_precision_loss)]
 #[instrument(skip(bytes))]
 pub fn extract(bytes: &Vec<u8>, extract_directories: ExtractDirectories) -> Result<Vec<PathBuf>> {
     let mut files = Vec::new();
@@ -47,7 +45,7 @@ pub fn extract(bytes: &Vec<u8>, extract_directories: ExtractDirectories) -> Resu
     debug!(
         "Extracted {} files totalling {}",
         number_of_files.to_formatted_string(&Locale::en),
-        human_bytes(extracted_bytes as f64)
+        extracted_bytes,
     );
 
     Ok(files)
diff --git a/postgresql_archive/src/repository/github/repository.rs b/postgresql_archive/src/repository/github/repository.rs
@@ -9,7 +9,6 @@ use crate::{hasher, matcher, Result};
 use async_trait::async_trait;
 use futures_util::StreamExt;
 use http::{header, Extensions};
-use human_bytes::human_bytes;
 use regex::Regex;
 use reqwest::{Request, Response};
 use reqwest_middleware::{ClientBuilder, ClientWithMiddleware, Middleware, Next};
@@ -216,7 +215,6 @@ impl Repository for GitHub {
     }
 
     #[instrument]
-    #[expect(clippy::cast_precision_loss)]
     async fn get_archive(&self, version_req: &VersionReq) -> Result<Archive> {
         let release = self.get_release(version_req).await?;
         let version = Self::get_version_from_tag_name(release.tag_name.as_str())?;
@@ -239,7 +237,7 @@ impl Repository for GitHub {
         debug!(
             "Archive {} downloaded: {}",
             asset.browser_download_url,
-            human_bytes(bytes.len() as f64)
+            bytes.len(),
         );
 
         if let Some(asset_hash) = asset_hash {
@@ -264,7 +262,7 @@ impl Repository for GitHub {
             debug!(
                 "Archive hash {} downloaded: {}",
                 asset_hash.browser_download_url,
-                human_bytes(text.len() as f64)
+                text.len(),
             );
 
             if archive_hash != hash {
diff --git a/postgresql_archive/src/repository/maven/repository.rs b/postgresql_archive/src/repository/maven/repository.rs
@@ -6,7 +6,6 @@ use crate::{hasher, Result};
 use async_trait::async_trait;
 use futures_util::StreamExt;
 use http::{header, Extensions};
-use human_bytes::human_bytes;
 use reqwest::{Request, Response};
 use reqwest_middleware::{ClientBuilder, ClientWithMiddleware, Middleware, Next};
 use reqwest_retry::policies::ExponentialBackoff;
@@ -62,7 +61,7 @@ impl Maven {
         let response = request.send().await?.error_for_status()?;
         let text = response.text().await?;
         let metadata: Metadata =
-            quick_xml::de::from_str(&text).map_err(|error| ParseError(error.into()))?;
+            quick_xml::de::from_str(&text).map_err(|error| ParseError(error.to_string()))?;
         let artifact = metadata.artifact_id;
         let mut result = None;
         for version in &metadata.versioning.versions.version {
@@ -103,7 +102,6 @@ impl Repository for Maven {
     }
 
     #[instrument]
-    #[expect(clippy::cast_precision_loss)]
     async fn get_archive(&self, version_req: &VersionReq) -> Result<Archive> {
         let (artifact, version) = self.get_artifact(version_req).await?;
         let archive_name = format!("{artifact}-{version}.jar");
@@ -129,10 +127,7 @@ impl Repository for Maven {
         let request = client.get(&archive_hash_url);
         let response = request.send().await?.error_for_status()?;
         let hash = response.text().await?;
-        debug!(
-            "Archive hash {archive_hash_url} downloaded: {}",
-            human_bytes(hash.len() as f64)
-        );
+        debug!("Archive hash {archive_hash_url} downloaded: {}", hash.len(),);
 
         debug!("Downloading archive {archive_url}");
         let request = client.get(&archive_url);
@@ -146,10 +141,7 @@ impl Repository for Maven {
             bytes.write_all(&chunk?)?;
             span.pb_set_position(bytes.len() as u64);
         }
-        debug!(
-            "Archive {archive_url} downloaded: {}",
-            human_bytes(bytes.len() as f64)
-        );
+        debug!("Archive {archive_url} downloaded: {}", bytes.len(),);
 
         let archive_hash = hasher_fn(&bytes)?;
         if archive_hash != hash {
diff --git a/postgresql_commands/Cargo.toml b/postgresql_commands/Cargo.toml
@@ -13,7 +13,6 @@ version.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-anyhow = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["full"], optional = true }
 tracing = { workspace = true, features = ["log"] }
diff --git a/postgresql_commands/src/error.rs b/postgresql_commands/src/error.rs
@@ -8,25 +8,25 @@ pub enum Error {
     #[error("Command error: stdout={stdout}; stderr={stderr}")]
     CommandError { stdout: String, stderr: String },
     /// Error when IO operations fail
-    #[error(transparent)]
-    IoError(anyhow::Error),
+    #[error("{0}")]
+    IoError(String),
     /// Error when a command fails to execute before the timeout is reached
-    #[error(transparent)]
-    TimeoutError(anyhow::Error),
+    #[error("{0}")]
+    TimeoutError(String),
 }
 
 /// Convert [standard IO errors](std::io::Error) to a [embedded errors](Error::IoError)
 impl From<std::io::Error> for Error {
     fn from(error: std::io::Error) -> Self {
-        Error::IoError(error.into())
+        Error::IoError(error.to_string())
     }
 }
 
 #[cfg(feature = "tokio")]
 /// Convert [elapsed time errors](tokio::time::error::Elapsed) to [embedded errors](Error::TimeoutError)
 impl From<tokio::time::error::Elapsed> for Error {
     fn from(error: tokio::time::error::Elapsed) -> Self {
-        Error::TimeoutError(error.into())
+        Error::TimeoutError(error.to_string())
     }
 }
 
diff --git a/postgresql_embedded/Cargo.toml b/postgresql_embedded/Cargo.toml
@@ -19,7 +19,6 @@ tokio = { workspace = true, features = ["full"] }
 url = { workspace = true }
 
 [dependencies]
-anyhow = { workspace = true }
 home = { workspace = true }
 postgresql_archive = { path = "../postgresql_archive", version = "0.17.4", default-features = false }
 postgresql_commands = { path = "../postgresql_commands", version = "0.17.4" }
@@ -33,6 +32,7 @@ tracing = { workspace = true, features = ["log"] }
 url = { workspace = true }
 
 [dev-dependencies]
+anyhow = { workspace = true }
 criterion = { workspace = true }
 test-log = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
diff --git a/postgresql_embedded/src/error.rs b/postgresql_embedded/src/error.rs
diff --git a/postgresql_embedded/src/postgresql.rs b/postgresql_embedded/src/postgresql.rs
diff --git a/postgresql_embedded/tests/postgresql.rs b/postgresql_embedded/tests/postgresql.rs

Original file line number	Diff line number	Diff line change
`@@ -17,11 +17,11 @@ pub enum Error {`
`17`	`17`	`#[error("version '{0}' is invalid")]`
`18`	`18`	`InvalidVersion(String),`
`19`	`19`	`/// IO error`
`20`		`- #[error(transparent)]`
`21`		`- IoError(anyhow::Error),`
	`20`	`+ #[error("{0}")]`
	`21`	`+ IoError(String),`
`22`	`22`	`/// Parse error`
`23`		`- #[error(transparent)]`
`24`		`- ParseError(anyhow::Error),`
	`23`	`+ #[error("{0}")]`
	`24`	`+ ParseError(String),`
`25`	`25`	`/// Poisoned lock`
`26`	`26`	`#[error("poisoned lock '{0}'")]`
`27`	`27`	`PoisonedLock(String),`
`@@ -51,70 +51,63 @@ pub enum Error {`
`51`	`51`	/// Converts a [`regex::Error`] into an [`ParseError`](Error::ParseError)
`52`	`52`	`impl From<regex::Error> for Error {`
`53`	`53`	`fn from(error: regex::Error) -> Self {`
`54`		`- Error::ParseError(error.into())`
	`54`	`+ Error::ParseError(error.to_string())`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	/// Converts a [`reqwest::Error`] into an [`IoError`](Error::IoError)
`59`	`59`	`impl From<reqwest::Error> for Error {`
`60`	`60`	`fn from(error: reqwest::Error) -> Self {`
`61`		`- Error::IoError(error.into())`
	`61`	`+ Error::IoError(error.to_string())`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	/// Converts a [`reqwest_middleware::Error`] into an [`IoError`](Error::IoError)
`66`	`66`	`impl From<reqwest_middleware::Error> for Error {`
`67`	`67`	`fn from(error: reqwest_middleware::Error) -> Self {`
`68`		`- Error::IoError(error.into())`
	`68`	`+ Error::IoError(error.to_string())`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	/// Converts a [`std::io::Error`] into an [`IoError`](Error::IoError)
`73`	`73`	`impl From<std::io::Error> for Error {`
`74`	`74`	`fn from(error: std::io::Error) -> Self {`
`75`		`- Error::IoError(error.into())`
	`75`	`+ Error::IoError(error.to_string())`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	/// Converts a [`std::time::SystemTimeError`] into an [`IoError`](Error::IoError)
`80`	`80`	`impl From<std::time::SystemTimeError> for Error {`
`81`	`81`	`fn from(error: std::time::SystemTimeError) -> Self {`
`82`		`- Error::IoError(error.into())`
	`82`	`+ Error::IoError(error.to_string())`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	/// Converts a [`std::num::ParseIntError`] into an [`ParseError`](Error::ParseError)
`87`	`87`	`impl From<std::num::ParseIntError> for Error {`
`88`	`88`	`fn from(error: std::num::ParseIntError) -> Self {`
`89`		`- Error::ParseError(error.into())`
	`89`	`+ Error::ParseError(error.to_string())`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	/// Converts a [`semver::Error`] into an [`ParseError`](Error::ParseError)
`94`	`94`	`impl From<semver::Error> for Error {`
`95`	`95`	`fn from(error: semver::Error) -> Self {`
`96`		`- Error::IoError(error.into())`
	`96`	`+ Error::IoError(error.to_string())`
`97`	`97`	`}`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	/// Converts a [`std::path::StripPrefixError`] into an [`ParseError`](Error::ParseError)
`101`	`101`	`impl From<std::path::StripPrefixError> for Error {`
`102`	`102`	`fn from(error: std::path::StripPrefixError) -> Self {`
`103`		`- Error::ParseError(error.into())`
`104`		`- }`
`105`		`-}`
`106`		`-`
`107`		-/// Converts a [`anyhow::Error`] into an [`Unexpected`](Error::Unexpected)
`108`		`-impl From<anyhow::Error> for Error {`
`109`		`- fn from(error: anyhow::Error) -> Self {`
`110`		`- Error::Unexpected(error.to_string())`
	`103`	`+ Error::ParseError(error.to_string())`
`111`	`104`	`}`
`112`	`105`	`}`
`113`	`106`
`114`	`107`	/// Converts a [`url::ParseError`] into an [`ParseError`](Error::ParseError)
`115`	`108`	`impl From<url::ParseError> for Error {`
`116`	`109`	`fn from(error: url::ParseError) -> Self {`
`117`		`- Error::ParseError(error.into())`
	`110`	`+ Error::ParseError(error.to_string())`
`118`	`111`	`}`
`119`	`112`	`}`
`120`	`113`
`@@ -200,13 +193,6 @@ mod test {`
`200`	`193`	`);`
`201`	`194`	`}`
`202`	`195`
`203`		`- #[test]`
`204`		`- fn test_from_anyhow_error() {`
`205`		`- let anyhow_error = anyhow::Error::msg("test");`
`206`		`- let error = Error::from(anyhow_error);`
`207`		`- assert_eq!(error.to_string(), "test");`
`208`		`- }`
`209`		`-`
`210`	`196`	`#[test]`
`211`	`197`	`fn test_from_url_parse_error() {`
`212`	`198`	`let parse_error = url::ParseError::EmptyHost;`