Fix clippy warnings

Signed-off-by: Pragyan Poudyal <[email protected]>

Author: Johan-Liebert1

src/oci/mod.rs

@@ -241,7 +241,7 @@ impl<'repo> ImageOp<'repo> {
         let (done_chan_sender, done_chan_recver) =
             std::sync::mpsc::channel::<Result<(Sha256HashValue, Sha256HashValue)>>();
 
-        let chunk_len = (config.rootfs().diff_ids().len() + encoder_threads - 1) / encoder_threads;
+        let chunk_len = config.rootfs().diff_ids().len().div_ceil(encoder_threads);
 
         // Divide the layers into chunks of some specific size so each worker
         // thread can work on multiple deterministic layers
@@ -261,8 +261,7 @@ impl<'repo> ImageOp<'repo> {
         let layers_to_chunks = chunks
             .iter()
             .enumerate()
-            .map(|(i, chunk)| std::iter::repeat(i).take(chunk.len()).collect::<Vec<_>>())
-            .flatten()
+            .flat_map(|(i, chunk)| std::iter::repeat(i).take(chunk.len()).collect::<Vec<_>>())
             .collect::<Vec<_>>();
 
         let _ = (0..encoder_threads)
@@ -286,8 +285,7 @@ impl<'repo> ImageOp<'repo> {
                         );
 
                         if let Err(e) = enc.recv_data(receiver, start, end) {
-                            eprintln!("zstd_encoder returned with error: {}", e.to_string());
-                            return;
+                            eprintln!("zstd_encoder returned with error: {}", e)
                         }
                     }
                 });
@@ -312,18 +310,14 @@ impl<'repo> ImageOp<'repo> {
                             zstd_writer_channels,
                             layers_to_chunks,
                         ) {
-                            eprintln!(
-                                "handle_external_object returned with error: {}",
-                                e.to_string()
-                            );
-                            return;
+                            eprintln!("handle_external_object returned with error: {}", e);
                         }
                     }
                 });
             })
             .collect::<Vec<_>>();
 
-        return (done_chan_sender, done_chan_recver, object_sender);
+        (done_chan_sender, done_chan_recver, object_sender)
     }
 
     pub async fn pull(&self) -> Result<(Sha256HashValue, Sha256HashValue)> {

src/splitstream.rs

@@ -105,9 +105,7 @@ impl PartialEq for WriterMessagesData {
 
 impl PartialOrd for WriterMessagesData {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        self.object_data
-            .seq_num
-            .partial_cmp(&other.object_data.seq_num)
+        Some(self.cmp(other))
     }
 }
 

src/zstd_encoder.rs

@@ -161,15 +161,15 @@ impl ZstdWriter {
             panic!("`get_state` called on a single threaded writer")
         };
 
-        return state;
+        state
     }
 
     fn get_state_mut(&mut self) -> &mut MultiThreadedState {
         let WriterMode::MultiThreaded(state) = &mut self.mode else {
             panic!("`get_state_mut` called on a single threaded writer")
         };
 
-        return state;
+        state
     }
 
     fn instantiate_writer(refs: Option<DigestMap>) -> zstd::Encoder<'static, Vec<u8>> {
@@ -190,7 +190,7 @@ impl ZstdWriter {
             }
         }
 
-        return writer;
+        writer
     }
 
     pub(crate) fn write_fragment(&mut self, size: usize, data: &[u8]) -> Result<()> {
@@ -200,19 +200,19 @@ impl ZstdWriter {
 
     pub(crate) fn update_sha(&mut self, data: &[u8]) {
         if let Some((sha256, ..)) = &mut self.sha256_builder {
-            sha256.update(&data);
+            sha256.update(data);
         }
     }
 
     /// Writes all the data in `inline_content`, updating the internal SHA
-    pub(crate) fn flush_inline(&mut self, inline_content: &Vec<u8>) -> Result<()> {
+    pub(crate) fn flush_inline(&mut self, inline_content: &[u8]) -> Result<()> {
         if inline_content.is_empty() {
             return Ok(());
         }
 
         self.update_sha(inline_content);
 
-        self.write_fragment(inline_content.len(), &inline_content)?;
+        self.write_fragment(inline_content.len(), inline_content)?;
 
         Ok(())
     }
@@ -265,7 +265,7 @@ impl ZstdWriter {
     }
 
     pub(crate) fn finalize_sha256_builder(&mut self) -> Result<Sha256HashValue> {
-        let sha256_builder = std::mem::replace(&mut self.sha256_builder, None);
+        let sha256_builder = self.sha256_builder.take();
 
         if let Some((context, expected)) = sha256_builder {
             let final_sha = Into::<Sha256HashValue>::into(context.finalize());
@@ -305,7 +305,7 @@ impl ZstdWriter {
                 seq_num: final_message.total_msgs,
                 layer_num: final_message.layer_num,
             }))
-            .with_context(|| format!("Failed to send object finalize message"))?;
+            .context("Failed to send object finalize message")?;
 
         Ok(sha)
     }
@@ -374,6 +374,6 @@ impl ZstdWriter {
             }
         }
 
-        return Ok(false);
+        Ok(false)
     }
 }