fix: warnings about if statements that can be compacted

Author: jpraynaud

mithril-aggregator/src/dependency_injection/builder/support/sqlite.rs

@@ -53,10 +53,10 @@ impl DependenciesBuilder {
             let _ = connection.execute("pragma analysis_limit=400; pragma optimize;");
         }
 
-        if let Some(pool) = &self.sqlite_connection_cardano_transaction_pool {
-            if let Ok(connection) = pool.connection() {
-                let _ = connection.execute("pragma analysis_limit=400; pragma optimize;");
-            }
+        if let Some(pool) = &self.sqlite_connection_cardano_transaction_pool
+            && let Ok(connection) = pool.connection()
+        {
+            let _ = connection.execute("pragma analysis_limit=400; pragma optimize;");
         }
     }
 

mithril-aggregator/src/file_uploaders/cloud_uploader/api.rs

@@ -46,15 +46,14 @@ impl CloudUploader {
 impl FileUploader for CloudUploader {
     async fn upload_without_retry(&self, file_path: &Path) -> StdResult<FileUri> {
         let remote_file_path = self.remote_folder.join(get_file_name(file_path)?);
-        if !self.allow_overwrite {
-            if let Some(file_uri) = self
+        if !self.allow_overwrite
+            && let Some(file_uri) = self
                 .cloud_backend_uploader
                 .file_exists(&remote_file_path)
                 .await
                 .with_context(|| "checking if file exists in cloud")?
-            {
-                return Ok(file_uri);
-            }
+        {
+            return Ok(file_uri);
         }
 
         let file_uri = self

mithril-aggregator/src/services/certifier/buffered_certifier.rs

@@ -131,16 +131,15 @@ impl CertifierService for BufferedCertifierService {
             .create_open_message(signed_entity_type, protocol_message)
             .await;
 
-        if creation_result.is_ok() {
-            if let Err(error) = self
+        if creation_result.is_ok()
+            && let Err(error) = self
                 .try_register_buffered_signatures_to_current_open_message(signed_entity_type)
                 .await
-            {
-                warn!(self.logger, "Failed to register buffered signatures to the new open message";
-                    "signed_entity_type" => ?signed_entity_type,
-                    "error" => ?error
-                );
-            }
+        {
+            warn!(self.logger, "Failed to register buffered signatures to the new open message";
+                "signed_entity_type" => ?signed_entity_type,
+                "error" => ?error
+            );
         }
 
         creation_result

mithril-aggregator/src/tools/file_archiver/api.rs

@@ -69,16 +69,21 @@ impl FileArchiver {
         let temporary_archive_path = parameters.temporary_archive_path();
 
         let temporary_file_archive = self
-            .create_and_verify_archive(&temporary_archive_path, appender, parameters.compression_algorithm)
+            .create_and_verify_archive(
+                &temporary_archive_path,
+                appender,
+                parameters.compression_algorithm,
+            )
             .inspect_err(|_err| {
-                if temporary_archive_path.exists() {
-                    if let Err(remove_error) = fs::remove_file(&temporary_archive_path) {
-                        warn!(
-                            self.logger, " > Post FileArchiver.archive failure, could not remove temporary archive";
-                            "archive_path" => temporary_archive_path.display(),
-                            "error" => remove_error
-                        );
-                    }
+                if temporary_archive_path.exists()
+                    && let Err(remove_error) = fs::remove_file(&temporary_archive_path)
+                {
+                    warn!(
+                        self.logger,
+                        " > Post FileArchiver.archive failure, could not remove temporary archive";
+                        "archive_path" => temporary_archive_path.display(),
+                        "error" => remove_error
+                    );
                 }
             })
             .with_context(|| {

mithril-client-cli/src/utils/archive_unpacker/zip_unpacker.rs

@@ -32,12 +32,12 @@ impl ArchiveFormat for ZipUnpacker {
                     format!("Could not create directory '{}'", outpath.display())
                 })?;
             } else {
-                if let Some(parent) = outpath.parent() {
-                    if !parent.exists() {
-                        fs::create_dir_all(parent).with_context(|| {
-                            format!("Could not create directory '{}'", parent.display())
-                        })?;
-                    }
+                if let Some(parent) = outpath.parent()
+                    && !parent.exists()
+                {
+                    fs::create_dir_all(parent).with_context(|| {
+                        format!("Could not create directory '{}'", parent.display())
+                    })?;
                 }
                 let mut outfile = File::create(&outpath)
                     .with_context(|| format!("Could not create file '{}'", outpath.display()))?;

mithril-client/src/certificate_client/verify.rs

@@ -140,12 +140,12 @@ impl MithrilCertificateVerifier {
             .await?;
 
         #[cfg(feature = "unstable")]
-        if let Some(cache) = self.verifier_cache.as_ref() {
-            if !certificate.is_genesis() {
-                cache
-                    .store_validated_certificate(&certificate.hash, &certificate.previous_hash)
-                    .await?;
-            }
+        if let Some(cache) = self.verifier_cache.as_ref()
+            && !certificate.is_genesis()
+        {
+            cache
+                .store_validated_certificate(&certificate.hash, &certificate.previous_hash)
+                .await?;
         }
 
         trace!(self.logger, "Certificate validated"; "hash" => &certificate.hash, "previous_hash" => &certificate.previous_hash);

mithril-common/src/certificate_chain/certificate_verifier.rs

@@ -228,10 +228,9 @@ impl MithrilCertificateVerifier {
         if let Some(signed_epoch) = &certificate
             .protocol_message
             .get_message_part(&ProtocolMessagePartKey::CurrentEpoch)
+            && **signed_epoch == certificate.epoch.to_string()
         {
-            if **signed_epoch == certificate.epoch.to_string() {
-                return Ok(());
-            }
+            return Ok(());
         }
 
         Err(anyhow!(CertificateVerifierError::CertificateEpochUnmatch))

mithril-common/src/crypto_helper/merkle_map.rs

@@ -194,10 +194,10 @@ impl<K: MKMapKey, V: MKMapValue<K>, S: MKTreeStorer> MKMap<K, V, S> {
         let leaves_by_keys = self.group_leaves_by_keys(leaves);
         let mut sub_proofs = BTreeMap::<K, MKMapProof<K>>::default();
         for (key, sub_leaves) in leaves_by_keys {
-            if let Some(value) = self.get(&key) {
-                if let Some(proof) = value.compute_proof(&sub_leaves)? {
-                    sub_proofs.insert(key.to_owned(), proof);
-                }
+            if let Some(value) = self.get(&key)
+                && let Some(proof) = value.compute_proof(&sub_leaves)?
+            {
+                sub_proofs.insert(key.to_owned(), proof);
             }
         }