A bunch of clippy fixes

src/encoder/compression/deflate.rs

@@ -46,7 +46,7 @@ impl Compression for Deflate {
     const COMPRESSION_METHOD: CompressionMethod = CompressionMethod::Deflate;
 
     fn get_algorithm(&self) -> Compressor {
-        Compressor::Deflate(self.clone())
+        Compressor::Deflate(*self)
     }
 }
 

src/encoder/compression/lzw.rs

@@ -41,7 +41,7 @@ mod tests {
 
         let mut compressed_data = Vec::<u8>::new();
         let mut writer = Cursor::new(&mut compressed_data);
-        Lzw::default().write_to(&mut writer, TEST_DATA).unwrap();
+        Lzw.write_to(&mut writer, TEST_DATA).unwrap();
         assert_eq!(EXPECTED_COMPRESSED_DATA, compressed_data.as_slice());
     }
 }

src/encoder/compression/mod.rs

@@ -38,7 +38,7 @@ pub enum Compressor {
 impl Default for Compressor {
     /// The default compression strategy does not apply any compression.
     fn default() -> Self {
-        Compressor::Uncompressed(Uncompressed::default())
+        Compressor::Uncompressed(Uncompressed)
     }
 }
 
@@ -55,6 +55,6 @@ impl CompressionAlgorithm for Compressor {
 
 #[cfg(test)]
 mod tests {
-    pub const TEST_DATA: &'static [u8] =
+    pub const TEST_DATA: &[u8] =
         b"This is a string for checking various compression algorithms.";
 }

src/encoder/compression/packbits.rs

@@ -80,33 +80,31 @@ impl CompressionAlgorithm for Packbits {
                     run_index = 0;
                     in_run = false;
                 }
-            } else {
-                if bytes_pending > MAX_BYTES {
-                    // We have as much differing data as we can output in one chunk.
-                    // Output MAX_BYTES leaving one byte.
-                    offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(MAX_BYTES))?);
-                    bufwriter.write(&bytes[pending_index..pending_index + MAX_BYTES as usize])?;
-                    bytes_written += 1 + MAX_BYTES as u64;
+            } else if bytes_pending > MAX_BYTES {
+                // We have as much differing data as we can output in one chunk.
+                // Output MAX_BYTES leaving one byte.
+                offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(MAX_BYTES))?);
+                bufwriter.write_all(&bytes[pending_index..pending_index + MAX_BYTES as usize])?;
+                bytes_written += 1 + MAX_BYTES as u64;
 
-                    pending_index += MAX_BYTES as usize;
-                    bytes_pending -= MAX_BYTES;
-                    run_index = bytes_pending - 1; // A run could start here
-                } else if curr_byte == last_byte {
-                    if (bytes_pending - run_index >= MIN_REPT) || (run_index == 0) {
-                        // This is a worthwhile run
-                        if run_index != 0 {
-                            // Flush differing data out of input buffer
-                            offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(run_index))?);
-                            bufwriter
-                                .write(&bytes[pending_index..pending_index + run_index as usize])?;
-                            bytes_written += 1 + run_index as u64;
-                        }
-                        bytes_pending -= run_index; // Length of run
-                        in_run = true;
+                pending_index += MAX_BYTES as usize;
+                bytes_pending -= MAX_BYTES;
+                run_index = bytes_pending - 1; // A run could start here
+            } else if curr_byte == last_byte {
+                if (bytes_pending - run_index >= MIN_REPT) || (run_index == 0) {
+                    // This is a worthwhile run
+                    if run_index != 0 {
+                        // Flush differing data out of input buffer
+                        offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(run_index))?);
+                        bufwriter
+                            .write_all(&bytes[pending_index..pending_index + run_index as usize])?;
+                        bytes_written += 1 + run_index as u64;
                     }
-                } else {
-                    run_index = bytes_pending - 1; // A run could start here
+                    bytes_pending -= run_index; // Length of run
+                    in_run = true;
                 }
+            } else {
+                run_index = bytes_pending - 1; // A run could start here
             }
             last_byte = curr_byte;
         }
@@ -119,7 +117,7 @@ impl CompressionAlgorithm for Packbits {
         } else {
             bytes_written += 1 + bytes_pending as u64;
             offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(bytes_pending))?);
-            bufwriter.write(&bytes[pending_index..pending_index + bytes_pending as usize])?;
+            bufwriter.write_all(&bytes[pending_index..pending_index + bytes_pending as usize])?;
         }
 
         bufwriter.flush()?;
@@ -141,7 +139,7 @@ mod tests {
 
         let mut compressed_data = Vec::<u8>::new();
         let mut writer = Cursor::new(&mut compressed_data);
-        Packbits::default()
+        Packbits
             .write_to(&mut writer, &UNCOMPRESSED_DATA)
             .unwrap();
         assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
@@ -150,13 +148,13 @@ mod tests {
     #[test]
     fn test_packbits_rept() {
         // compress buffer with repetitive sequence
-        const UNCOMPRESSED_DATA: &'static [u8] =
+        const UNCOMPRESSED_DATA: &[u8] =
             b"This strrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrring hangs.";
-        const EXPECTED_COMPRESSED_DATA: &'static [u8] = b"\x06This st\xD1r\x09ing hangs.";
+        const EXPECTED_COMPRESSED_DATA: &[u8] = b"\x06This st\xD1r\x09ing hangs.";
 
         let mut compressed_data = Vec::<u8>::new();
         let mut writer = Cursor::new(&mut compressed_data);
-        Packbits::default()
+        Packbits
             .write_to(&mut writer, UNCOMPRESSED_DATA)
             .unwrap();
         assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
@@ -192,7 +190,7 @@ mod tests {
 
         let mut compressed_data = Vec::<u8>::new();
         let mut writer = Cursor::new(&mut compressed_data);
-        Packbits::default()
+        Packbits
             .write_to(&mut writer, data.as_slice())
             .unwrap();
         assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
@@ -201,12 +199,12 @@ mod tests {
     #[test]
     fn test_packbits() {
         // compress teststring
-        const EXPECTED_COMPRESSED_DATA: &'static [u8] =
+        const EXPECTED_COMPRESSED_DATA: &[u8] =
             b"\x3CThis is a string for checking various compression algorithms.";
 
         let mut compressed_data = Vec::<u8>::new();
         let mut writer = Cursor::new(&mut compressed_data);
-        Packbits::default()
+        Packbits
             .write_to(&mut writer, TEST_DATA)
             .unwrap();
         assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);

src/encoder/compression/uncompressed.rs

@@ -29,7 +29,7 @@ mod tests {
     fn test_no_compression() {
         let mut compressed_data = Vec::<u8>::new();
         let mut writer = Cursor::new(&mut compressed_data);
-        Uncompressed::default()
+        Uncompressed
             .write_to(&mut writer, TEST_DATA)
             .unwrap();
         assert_eq!(TEST_DATA, compressed_data);