fix: remove redundant borrows in format! and refactor match to use ?

Remove unnecessary `&` references in format! macro arguments across
multiple crates, and simplify a match expression in
device_credential_locations.rs to use the `?` operator.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Signed-off-by: Miguel Martín <mmartinv@redhat.com>

Author: mmartinv

http-wrapper/src/client.rs

@@ -214,7 +214,7 @@ impl ServiceClient {
 
         let url = format!(
             "{}/fdo/{}/msg/{}",
-            &self.base_url,
+            self.base_url,
             self.protocol_version,
             OM::message_type() as u8
         );

manufacturing-client/src/main.rs

@@ -748,9 +748,9 @@ impl KeyReference {
         let hmac_key_path = env::var("DI_HMAC_KEY_PATH").context("No DI HMAC key path set")?;
 
         let sign_key = fs::read(&sign_key_path)
-            .with_context(|| format!("Error reading sign key from {}", &sign_key_path))?;
+            .with_context(|| format!("Error reading sign key from {}", sign_key_path))?;
         let hmac_key = fs::read(&hmac_key_path)
-            .with_context(|| format!("Error reading HMAC key from {}", &hmac_key_path))?;
+            .with_context(|| format!("Error reading HMAC key from {}", hmac_key_path))?;
 
         let sign_key = PKey::private_key_from_der(&sign_key).context("Error loading sign key")?;
 

owner-onboarding-server/src/main.rs

@@ -408,7 +408,7 @@ async fn main() -> Result<()> {
         .map(|path| -> Result<X5Bag, anyhow::Error> {
             let trusted_device_keys = {
                 let contents = std::fs::read(path)
-                    .with_context(|| format!("Error reading trusted device keys at {}", &path))?;
+                    .with_context(|| format!("Error reading trusted device keys at {}", path))?;
                 X509::stack_from_pem(&contents).context("Error parsing trusted device keys")?
             };
 
@@ -422,14 +422,14 @@ async fn main() -> Result<()> {
     let owner_key = load_private_key(&settings.owner_private_key_path).with_context(|| {
         format!(
             "Error loading owner key from {}",
-            &settings.owner_private_key_path
+            settings.owner_private_key_path
         )
     })?;
     let owner_pubkey = {
         let contents = std::fs::read(&settings.owner_public_key_path).with_context(|| {
             format!(
                 "Error reading owner public key from {}",
-                &settings.owner_public_key_path
+                settings.owner_public_key_path
             )
         })?;
         PublicKey::try_from(X509::from_pem(&contents).context("Error parsing owner public key")?)

owner-tool/src/main.rs

@@ -647,7 +647,7 @@ async fn export_manufacturer_vouchers(args: &ExportManufacturerVouchersArguments
         let ov = client
             .get(format!(
                 "{}/ov/{}",
-                &args.manufacturer_server_url, device_guid
+                args.manufacturer_server_url, device_guid
             ))
             .send()
             .await?
@@ -659,7 +659,7 @@ async fn export_manufacturer_vouchers(args: &ExportManufacturerVouchersArguments
         let ovs_tar_path = path.join("export.tar");
         let mut ovs_tar = File::create(ovs_tar_path)?;
         let ovs = client
-            .post(format!("{}/export", &args.manufacturer_server_url))
+            .post(format!("{}/export", args.manufacturer_server_url))
             .send()
             .await?
             .bytes()
@@ -682,14 +682,14 @@ fn import_ownership_vouchers(args: &ImportOwnershipVouchersArguments) -> Result<
             let ov_path = match &path {
                 Ok(path) => path.path(),
                 Err(e) => {
-                    error_buff.push(format!("Error {e} with path {:?}", &path));
+                    error_buff.push(format!("Error {e} with path {:?}", path));
                     continue;
                 }
             };
             let content = match fs::read(&ov_path) {
                 Ok(value) => value,
                 Err(e) => {
-                    error_buff.push(format!("Error {e} reading path {:?}", &ov_path));
+                    error_buff.push(format!("Error {e} reading path {:?}", ov_path));
                     continue;
                 }
             };
@@ -698,7 +698,7 @@ fn import_ownership_vouchers(args: &ImportOwnershipVouchersArguments) -> Result<
                 Err(e) => {
                     error_buff.push(format!(
                         "Error {e} serializing OV contents at path {:?}",
-                        &ov_path
+                        ov_path
                     ));
                     continue;
                 }
@@ -712,7 +712,7 @@ fn import_ownership_vouchers(args: &ImportOwnershipVouchersArguments) -> Result<
                             error_buff.push(format!(
                                 "Error {e} getting a connection from the DB pool with OV {} from path {:?}",
                                 ov.header().guid(),
-                                &ov_path
+                                ov_path
                             ));
                             continue;
                         }
@@ -727,7 +727,7 @@ fn import_ownership_vouchers(args: &ImportOwnershipVouchersArguments) -> Result<
                             error_buff.push(format!(
                                 "Error {e} getting a connection from the DB pool with OV {} from path {:?}",
                                 ov.header().guid(),
-                                &ov_path
+                                ov_path
                             ));
                             continue;
                         }
@@ -740,7 +740,7 @@ fn import_ownership_vouchers(args: &ImportOwnershipVouchersArguments) -> Result<
                     "Error {:?} inserting OV {} from path {:?}",
                     ret.err(),
                     ov.header().guid(),
-                    &ov_path
+                    ov_path
                 ));
             }
         }

rendezvous-server/src/main.rs

@@ -93,7 +93,7 @@ async fn main() -> Result<()> {
         .map(|path| -> Result<X5Bag, anyhow::Error> {
             let trusted_manufacturer_keys = {
                 let contents = std::fs::read(&path).with_context(|| {
-                    format!("Error reading trusted manufacturer keys at {}", &path)
+                    format!("Error reading trusted manufacturer keys at {}", path)
                 })?;
                 X509::stack_from_pem(&contents)
                     .context("Error parsing trusted manufacturer keys")?
@@ -111,7 +111,7 @@ async fn main() -> Result<()> {
         .map(|path| -> Result<X5Bag, anyhow::Error> {
             let trusted_device_keys = {
                 let contents = std::fs::read(path)
-                    .with_context(|| format!("Error reading trusted device keys at {}", &path))?;
+                    .with_context(|| format!("Error reading trusted device keys at {}", path))?;
                 X509::stack_from_pem(&contents).context("Error parsing trusted device keys")?
             };
             X5Bag::with_certs(trusted_device_keys)

util/src/device_credential_locations.rs

@@ -60,7 +60,7 @@ impl DeviceCredentialLocation for FileSystemPath {
         if Path::new(&self.path).exists() {
             Some(Ok(Box::new(self.clone())))
         } else {
-            log::trace!("No (device credential) file exists at {}", &self.path);
+            log::trace!("No (device credential) file exists at {}", self.path);
             None
         }
     }
@@ -69,17 +69,17 @@ impl DeviceCredentialLocation for FileSystemPath {
 impl UsableDeviceCredentialLocation for FileSystemPath {
     fn read(&self) -> Result<Box<dyn DeviceCredential>> {
         let contents = fs::read(&self.path)
-            .with_context(|| format!("Error reading (device credential) file at {}", &self.path))?;
+            .with_context(|| format!("Error reading (device credential) file at {}", self.path))?;
         let fdc = FileDeviceCredential::deserialize_data(&contents)
-            .with_context(|| format!("Error parsing device credential from {}", &self.path))?;
+            .with_context(|| format!("Error parsing device credential from {}", self.path))?;
         Ok(Box::new(fdc))
     }
 
     fn deactivate(&self) -> Result<()> {
         match self.deactivation_method {
             DeactivationMethod::None => Ok(()),
             DeactivationMethod::Delete => fs::remove_file(&self.path)
-                .with_context(|| format!("Error deleting file at {}", &self.path)),
+                .with_context(|| format!("Error deleting file at {}", self.path)),
             DeactivationMethod::Deactivate => self.perform_deactivation(),
         }
     }
@@ -88,9 +88,9 @@ impl UsableDeviceCredentialLocation for FileSystemPath {
 impl FileSystemPath {
     fn perform_deactivation(&self) -> Result<()> {
         let contents = fs::read(&self.path)
-            .with_context(|| format!("Error reading (device credential) file at {}", &self.path))?;
+            .with_context(|| format!("Error reading (device credential) file at {}", self.path))?;
         let mut fdc = FileDeviceCredential::deserialize_data(&contents)
-            .with_context(|| format!("Error parsing device credential from {}", &self.path))?;
+            .with_context(|| format!("Error parsing device credential from {}", self.path))?;
 
         fdc.active = false;
         let new_dc_contents = fdc
@@ -102,7 +102,7 @@ impl FileSystemPath {
 
     fn write(&self, new_contents: Vec<u8>) -> Result<()> {
         fs::write(&self.path, new_contents)
-            .with_context(|| format!("Error writing to file at {}", &self.path))
+            .with_context(|| format!("Error writing to file at {}", self.path))
     }
 }
 
@@ -113,23 +113,24 @@ struct FileSystemPathEnv {
 
 impl DeviceCredentialLocation for FileSystemPathEnv {
     fn resolve(&self) -> Option<Result<Box<dyn UsableDeviceCredentialLocation>>> {
-        let env_val = match env::var_os(&self.env_var) {
-            None => return None,
-            Some(v) => match v.into_string() {
+        let env_val = {
+            let v = env::var_os(&self.env_var)?;
+            match v.into_string() {
                 Ok(s) => s,
                 Err(_) => return Some(Err(anyhow!("Invalid environment variable value"))),
-            },
+            }
         };
-        let deactivation_method = match env::var_os(format!("{}_DELETE", &self.env_var)) {
-            None => match env::var_os(format!("{}_DEACTIVATE", &self.env_var)) {
+
+        let deactivation_method = match env::var_os(format!("{}_DELETE", self.env_var)) {
+            None => match env::var_os(format!("{}_DEACTIVATE", self.env_var)) {
                 None => DeactivationMethod::None,
                 Some(_) => DeactivationMethod::Deactivate,
             },
             Some(_) => DeactivationMethod::Delete,
         };
         log::trace!(
             "Resolved environment variable {} to filesystem path {} (deactivation method {:?})",
-            &self.env_var,
+            self.env_var,
             &env_val,
             &deactivation_method,
         );