Selective fmt

Roughsketch · Jul 4, 2021 · eb2fdcb · eb2fdcb
1 parent e756d48
commit eb2fdcb
Show file tree

Hide file tree

Showing 10 changed files with 40 additions and 33 deletions.
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,8 +1,8 @@
 use std::error::Error;
 use std::fmt;
 use std::fs::File;
-use std::path::Path;
 use std::io::{BufRead, BufReader, Cursor, Read, Seek, SeekFrom};
+use std::path::Path;
 
 mod util;
 use crate::util::*;
@@ -84,15 +84,13 @@ pub fn image_type(header: &[u8]) -> ImageResult<ImageType> {
             return Ok(ImageType::Tiff);
         } else if header.len() >= 4 && &header[0..4] == b"8BPS" {
             return Ok(ImageType::Psd);
-        } else if header.len() >= 8 &&
-            &header[4..8] == b"ftyp" {
+        } else if header.len() >= 8 && &header[4..8] == b"ftyp" {
             return Ok(ImageType::Heif);
-        } else if header.len() >= 12 &&
-            &header[0..4] == b"RIFF" &&
-            &header[8..12] == b"WEBP"{
+        } else if header.len() >= 12 && &header[0..4] == b"RIFF" && &header[8..12] == b"WEBP" {
             return Ok(ImageType::Webp);
-        } else if (header.len() >= 2 && &header[0..2] == b"\xFF\x0A") ||
-            (header.len() >= 12 && &header[0..12] == b"\x00\x00\x00\x0CJXL \x0D\x0A\x87\x0A") {
+        } else if (header.len() >= 2 && &header[0..2] == b"\xFF\x0A")
+            || (header.len() >= 12 && &header[0..12] == b"\x00\x00\x00\x0CJXL \x0D\x0A\x87\x0A")
+        {
             return Ok(ImageType::Jxl);
         } else {
             return Err(ImageError::NotSupported);
@@ -134,7 +132,10 @@ pub fn image_type(header: &[u8]) -> ImageResult<ImageType> {
 /// ```
 ///
 /// [`ImageError`]: enum.ImageError.html
-pub fn size<P>(path: P) -> ImageResult<ImageSize> where P: AsRef<Path> {
+pub fn size<P>(path: P) -> ImageResult<ImageSize>
+where
+    P: AsRef<Path>,
+{
     let file = File::open(path)?;
     let mut reader = BufReader::new(file);
 
@@ -211,7 +212,7 @@ fn bmp_size<R: BufRead + Seek>(reader: &mut R) -> ImageResult<ImageSize> {
 fn gif_size(header: &[u8]) -> ImageResult<ImageSize> {
     Ok(ImageSize {
         width:  ((header[6] as usize) | ((header[7] as usize) << 8)),
-        height: ((header[8] as usize) | ((header[9] as usize) << 8))
+        height: ((header[8] as usize) | ((header[9] as usize) << 8)),
     })
 }
 
@@ -228,7 +229,7 @@ fn heif_size<R: BufRead + Seek>(reader: &mut R) -> ImageResult<ImageSize> {
     read_u32(reader, &Endian::Big)?;    //  Meta has a junk value after it
     skip_to_tag(reader, b"iprp")?;      //  Find iprp tag
 
-    let mut ipco_size = skip_to_tag(reader, b"ipco")? as usize;      //  Find ipco tag
+    let mut ipco_size = skip_to_tag(reader, b"ipco")? as usize; //  Find ipco tag
 
     //  Keep track of the max size of ipco tag
     let mut max_width = 0usize;
@@ -245,7 +246,7 @@ fn heif_size<R: BufRead + Seek>(reader: &mut R) -> ImageResult<ImageSize> {
         //  ispe tag has a junk value followed by width and height as u32
         if tag == "ispe" {
             found_ispe = true;
-            read_u32(reader, &Endian::Big)?;    //  Discard junk value
+            read_u32(reader, &Endian::Big)?; //  Discard junk value
             let width = read_u32(reader, &Endian::Big)? as usize;
             let height = read_u32(reader, &Endian::Big)? as usize;
 
@@ -281,7 +282,7 @@ fn heif_size<R: BufRead + Seek>(reader: &mut R) -> ImageResult<ImageSize> {
 
     Ok(ImageSize {
         width: max_width,
-        height: max_height
+        height: max_height,
     })
 }
 
@@ -386,11 +387,13 @@ fn jxl_size<R: BufRead + Seek>(reader: &mut R) -> ImageResult<ImageSize> {
                     let mut box_size = [0; 8];
                     reader.read_exact(&mut box_size)?;
                     u64::from_be_bytes(box_size)
-                },
+                }
                 _ => box_size as u64,
             };
 
-            let box_end = box_start.checked_add(box_size).ok_or(ImageError::CorruptedImage)?;
+            let box_end = box_start
+                .checked_add(box_size)
+                .ok_or(ImageError::CorruptedImage)?;
             let box_header_size = reader.stream_position()? - box_start;
 
             if box_size != 0 && box_size < box_header_size {
@@ -443,7 +446,7 @@ fn jxl_size<R: BufRead + Seek>(reader: &mut R) -> ImageResult<ImageSize> {
     // Parse the header data
 
     let file_header = u128::from_le_bytes(file_header);
-    let header_size = 8*header_size;
+    let header_size = 8 * header_size;
 
     let is_small = read_bits(file_header, 1, 16, header_size)? != 0;
 
@@ -510,13 +513,16 @@ fn jxl_size<R: BufRead + Seek>(reader: &mut R) -> ImageResult<ImageSize> {
                 false => 0,
                 true => read_bits(file_header, 3, metadata_offset + 2, header_size)?,
             }
-        },
+        }
     };
 
     if orientation < 4 {
         Ok(ImageSize { width, height })
     } else {
-        Ok(ImageSize { width: height, height: width })
+        Ok(ImageSize {
+            width: height,
+            height: width,
+        })
     }
 }
 
@@ -579,8 +585,7 @@ fn tiff_size<R: BufRead + Seek>(reader: &mut R) -> ImageResult<ImageSize> {
             //  Skip the type/count since we just need the value
             reader.seek(SeekFrom::Current(6))?;
             width = Some(read_u32(reader, &endianness)?);
-        }
-        else if tag == 0x101 {
+        } else if tag == 0x101 {
             //  Skip the type/count since we just need the value
             reader.seek(SeekFrom::Current(6))?;
             height = Some(read_u32(reader, &endianness)?);
@@ -657,4 +662,4 @@ fn webp_vp8_size<R: BufRead + Seek>(reader: &mut R) -> ImageResult<ImageSize> {
         width: read_u16(reader, &Endian::Little)? as usize,
         height: read_u16(reader, &Endian::Little)? as usize,
     })
-}
+}
diff --git a/tests/blob.rs b/tests/blob.rs
@@ -35,4 +35,4 @@ fn blob_test_fail() {
 fn gif_blob_too_small_test() {
     let data = vec![0x47, 0x49, 0x46, 0x38];
     assert_eq!(blob_size(&data).is_err(), true);
-}
+}
diff --git a/tests/bmp.rs b/tests/bmp.rs
@@ -6,4 +6,4 @@ fn bmp_test() {
     let dim = size("test/bmp/test.bmp").unwrap();
     assert_eq!(dim.width, 512);
     assert_eq!(dim.height, 512);
-}
+}
diff --git a/tests/fuzz.rs b/tests/fuzz.rs
@@ -1,16 +1,18 @@
 #[cfg(test)]
 use imagesize::blob_size;
 use std::{
-    fs::{File, metadata, read_dir},
+    fs::{metadata, read_dir, File},
     io::{Error, Read},
     path::PathBuf,
 };
 
 #[test]
 fn fuzzer_crashes_fixed() {
-    let mut entries = read_dir("test/fuzz_crashes").unwrap()
+    let mut entries = read_dir("test/fuzz_crashes")
+        .unwrap()
         .map(|res| res.map(|e| e.path()))
-        .collect::<Result<Vec<_>, Error>>().unwrap();
+        .collect::<Result<Vec<_>, Error>>()
+        .unwrap();
 
     entries.sort();
 
@@ -27,4 +29,4 @@ fn get_file_as_byte_vec(filename: PathBuf) -> Vec<u8> {
     f.read(&mut buffer).expect("buffer overflow");
 
     buffer
-}
+}
diff --git a/tests/gif.rs b/tests/gif.rs
@@ -6,4 +6,4 @@ fn gif_test() {
     let dim = size("test/gif/test.gif").unwrap();
     assert_eq!(dim.width, 100);
     assert_eq!(dim.height, 100);
-}
+}
diff --git a/tests/heic.rs b/tests/heic.rs
@@ -13,4 +13,4 @@ fn heif_multi_picks_largest() {
     let dim = size("test/heic/IMG_0007.heic").unwrap();
     assert_eq!(dim.width, 2448);
     assert_eq!(dim.height, 3264);
-}
+}
diff --git a/tests/png.rs b/tests/png.rs
@@ -13,4 +13,4 @@ fn png_test() {
     let dim = size("test/png/test.png").unwrap();
     assert_eq!(dim.width, 690);
     assert_eq!(dim.height, 298);
-}
+}
diff --git a/tests/psd.rs b/tests/psd.rs
@@ -6,4 +6,4 @@ fn psd_test() {
     let dim = size("test/psd/test.psd").unwrap();
     assert_eq!(dim.width, 500);
     assert_eq!(dim.height, 500);
-}
+}
diff --git a/tests/tif.rs b/tests/tif.rs
@@ -6,4 +6,4 @@ fn tiff_test() {
     let dim = size("test/tif/test.tif").unwrap();
     assert_eq!(dim.width, 1419);
     assert_eq!(dim.height, 1001);
-}
+}
diff --git a/tests/webp.rs b/tests/webp.rs
@@ -34,4 +34,4 @@ fn webp_lossy() {
     let dim = size("test/webp/lossy.16x32.webp").unwrap();
     assert_eq!(dim.width, 16);
     assert_eq!(dim.height, 32);
-}
+}