Replace deprecated wrap_err_as_user/system with wrap_user_err/system_err

Co-authored-by: notheotherben <1760260+notheotherben@users.noreply.github.com>

Author: Copilot

src/config.rs

@@ -17,11 +17,11 @@ impl TryFrom<&Args> for Config {
     type Error = human_errors::Error;
 
     fn try_from(value: &Args) -> Result<Self, Self::Error> {
-        let content = std::fs::read_to_string(&value.config).wrap_err_as_user(
+        let content = std::fs::read_to_string(&value.config).wrap_user_err(
             format!("Failed to read the config file {}.", &value.config),
             &["Make sure that the configuration file exists and can be ready by the process."],
         )?;
-        let config: Config = serde_yaml::from_str(&content).wrap_err_as_user(
+        let config: Config = serde_yaml::from_str(&content).wrap_user_err(
             "Failed to parse your configuration file, as it is not recognized as valid YAML.",
             &["Make sure that your configuration file is formatted correctly."],
         )?;

src/engines/git.rs

@@ -52,7 +52,7 @@ impl BackupEngine<GitRepo> for GitEngine {
 impl GitEngine {
     fn ensure_directory(&self, path: &Path) -> Result<(), human_errors::Error> {
         trace!("Ensuring directory exists: {}", path.display());
-        std::fs::create_dir_all(path).wrap_err_as_user(
+        std::fs::create_dir_all(path).wrap_user_err(
             format!("Unable to create backup directory '{}'", path.display()),
             &["Make sure that you have permission to create the directory."],
         )
@@ -70,7 +70,7 @@ impl GitEngine {
             repo.clone_url,
             target.display()
         );
-        let mut fetch = gix::prepare_clone(repo.clone_url.as_str(), target).wrap_err_as_system(
+        let mut fetch = gix::prepare_clone(repo.clone_url.as_str(), target).wrap_system_err(
             format!("Failed to clone the repository {}.", &repo.clone_url),
             &["Please make sure that the target directory is writable and that the repository is accessible."],
         )?;
@@ -87,7 +87,7 @@ impl GitEngine {
         }
 
         trace!("Running clone in bare mode (not checking out files)");
-        let (repository, _outcome) = fetch.fetch_only(Discard, cancel).wrap_err_as_system(
+        let (repository, _outcome) = fetch.fetch_only(Discard, cancel).wrap_system_err(
             format!("Unable to clone remote repository '{}'", repo.clone_url),
             &["Make sure that your internet connectivity is working correctly, and that your local git configuration is able to clone this repo."],
         )?;
@@ -97,15 +97,15 @@ impl GitEngine {
 
         trace!("Configuring core.bare for Git repository");
         self.update_config(&repository, |c| {
-            c.set_raw_value(&gix::config::tree::Core::BARE, "true").wrap_err_as_system(
+            c.set_raw_value(&gix::config::tree::Core::BARE, "true").wrap_system_err(
                 format!("Unable to set the 'core.bare' configuration option for repository '{}'", repo.name()),
                 &["Make sure that the git repository has been correctly initialized and run `git config core.bare true` to configure it correctly."],
             )?;
 
             Ok(())
         })?;
 
-        let head_id = repository.head_id().wrap_err_as_user(
+        let head_id = repository.head_id().wrap_user_err(
             format!("The repository '{}' did not have a valid HEAD, which may indicate that there is something wrong with the source repository.", &repo.clone_url),
             &["Make sure that the remote repository is valid."],
         )?;
@@ -121,7 +121,7 @@ impl GitEngine {
         cancel: &AtomicBool,
     ) -> Result<BackupState, human_errors::Error> {
         trace!("Opening repository {}", target.display());
-        let repository = gix::open(target).wrap_err_as_user(
+        let repository = gix::open(target).wrap_user_err(
             format!(
                 "Failed to open the repository '{}' at '{}'",
                 &repo.clone_url,
@@ -140,7 +140,7 @@ impl GitEngine {
             "Configuring fetch operation for repository {}",
             target.display()
         );
-        let remote = repository.find_fetch_remote(Some(repo.clone_url.as_str().into())).wrap_err_as_user(
+        let remote = repository.find_fetch_remote(Some(repo.clone_url.as_str().into())).wrap_user_err(
             format!(
                 "Failed to find the remote '{}' in the repository '{}'",
                 repo.clone_url,
@@ -155,7 +155,7 @@ impl GitEngine {
                 .map(|s| gix::bstr::BString::from(s.as_str()))
                 .collect::<Vec<gix::bstr::BString>>(),
               gix::remote::Direction::Fetch)
-            .wrap_err_as_user(
+            .wrap_user_err(
                 format!(
                     "Failed to configure the remote '{}' in the repository '{}' to fetch all branches.",
                     &repo.clone_url,
@@ -167,7 +167,7 @@ impl GitEngine {
         trace!("Connecting to remote repository {}", repo.clone_url);
         let mut connection = remote
             .connect(gix::remote::Direction::Fetch)
-            .wrap_err_as_user(
+            .wrap_user_err(
                 format!(
                     "Unable to establish connection to remote git repository '{}'",
                     &repo.clone_url
@@ -183,7 +183,7 @@ impl GitEngine {
         );
         connection
             .prepare_fetch(Discard, Default::default())
-            .wrap_err_as_user(
+            .wrap_user_err(
                 format!(
                     "Unable to prepare fetch from remote git repository '{}'",
                     &repo.clone_url
@@ -192,15 +192,15 @@ impl GitEngine {
             )?
             .with_write_packed_refs_only(true)
             .receive(Discard, cancel)
-            .wrap_err_as_user(
+            .wrap_user_err(
                 format!(
                     "Unable to fetch from remote git repository '{}'",
                     &repo.clone_url
                 ),
                 &["Make sure that the repository is available and correctly configured."],
             )?;
 
-        let head_id = repository.head_id().wrap_err_as_user(
+        let head_id = repository.head_id().wrap_user_err(
             format!("The repository '{}' did not have a valid HEAD, which may indicate that there is something wrong with the source repository.", &repo.clone_url),
             &["Make sure that the remote repository is valid."],
         )?;
@@ -286,7 +286,7 @@ impl GitEngine {
             repo.path().join("config"),
             gix::config::Source::Local,
         )
-        .wrap_err_as_system(
+        .wrap_system_err(
             format!(
                 "Unable to load git configuration for repository '{}'",
                 repo.path().display()
@@ -296,15 +296,15 @@ impl GitEngine {
 
         update(&mut config)?;
 
-        let mut file = std::fs::File::create(repo.path().join("config")).wrap_err_as_system(
+        let mut file = std::fs::File::create(repo.path().join("config")).wrap_system_err(
             format!(
                 "Unable to write git configuration for repository '{}'",
                 repo.path().display()
             ),
             &["Make sure that the git repository has been correctly initialized."],
         )?;
 
-        config.write_to(&mut file).wrap_err_as_system(
+        config.write_to(&mut file).wrap_system_err(
             format!(
                 "Unable to write git configuration for repository '{}'",
                 repo.path().display()

src/engines/http_file.rs

@@ -29,7 +29,7 @@ impl HttpFileEngine {
     }
 
     fn ensure_directory(&self, path: &Path) -> Result<(), human_errors::Error> {
-        std::fs::create_dir_all(path).wrap_err_as_user(
+        std::fs::create_dir_all(path).wrap_user_err(
             format!("Unable to create backup directory '{}'", path.display()),
             &["Make sure that you have permission to create the directory."],
         )
@@ -138,7 +138,7 @@ impl BackupEngine<HttpFile> for HttpFileEngine {
 
         let mut file = tokio::fs::File::create(temp_path.as_path())
             .await
-            .wrap_err_as_user(
+            .wrap_user_err(
                 format!(
                     "Unable to create temporary backup file '{}'.",
                     temp_path.as_path().display()
@@ -209,7 +209,7 @@ impl BackupEngine<HttpFile> for HttpFileEngine {
         }
 
         let state = if target_path.exists() {
-            tokio::fs::remove_file(&target_path).await.wrap_err_as_user(
+            tokio::fs::remove_file(&target_path).await.wrap_user_err(
               format!("Unable to remove original backup file '{}' prior to replacement with new file.", target_path.display()),
               &["Make sure that you have write (and delete) permission on the backup directory and try again."],
               )?;
@@ -245,7 +245,7 @@ impl BackupEngine<HttpFile> for HttpFileEngine {
             format!("{:x}", shasum),
         )
         .await
-        .wrap_err_as_user(
+        .wrap_user_err(
             format!(
                 "Unable to write SHA-256 checksum file for backup file '{}'.",
                 target_path.display()

src/filter/parser.rs

@@ -170,7 +170,7 @@ impl<'a, I: Iterator<Item = Result<Token<'a>, Error>>> Parser<'a, I> {
         match self.tokens.next() {
             Some(Ok(Token::True(..))) => Ok(true.into()),
             Some(Ok(Token::False(..))) => Ok(false.into()),
-            Some(Ok(Token::Number(loc, n))) => Ok(FilterValue::Number(n.parse().wrap_err_as_user(
+            Some(Ok(Token::Number(loc, n))) => Ok(FilterValue::Number(n.parse().wrap_user_err(
                 format!("Failed to parse the number '{n}' which you provided at {}.", loc),
                 &["Please make sure that the number is well formatted. It should be in the form 123, or 123.45."],
             )?)),

src/helpers/github.rs

@@ -61,11 +61,11 @@ impl GitHubClient {
               let resp = self.call(Method::GET, &url, creds, |r| r, cancel).await?;
 
               if let Some(link_header) = resp.headers().get(LINK) {
-                  let link_header = link_header.to_str().wrap_err_as_system(
+                  let link_header = link_header.to_str().wrap_system_err(
                       "Unable to parse GitHub's Link header due to invalid characters, which will result in pagination failing to work correctly.",
                       &["Please report this issue to us on GitHub."])?;
 
-                  let links = parse_link_header::parse_with_rel(link_header).wrap_err_as_system(
+                  let links = parse_link_header::parse_with_rel(link_header).wrap_system_err(
                     "Unable to parse GitHub's Link header, which will result in pagination failing to work correctly.",
                     &["Please report this issue to us on GitHub."])?;
 
@@ -107,7 +107,7 @@ impl GitHubClient {
     where
         B: FnOnce(reqwest::RequestBuilder) -> reqwest::RequestBuilder,
     {
-        let parsed_url: Url = url.as_ref().parse().wrap_err_as_user(
+        let parsed_url: Url = url.as_ref().parse().wrap_user_err(
             format!(
                 "Unable to parse GitHub URL '{}' as a valid URL.",
                 url.as_ref()