Ran rustfmt and added formatting checks to CI

.github/workflows/rust.yml

@@ -70,6 +70,7 @@ jobs:
         env:
           FEATURES: ${{ matrix.features }}
           CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER: aarch64-linux-gnu-gcc
+
   cross_compile_wasm:
     runs-on: ubuntu-latest
     steps:
@@ -96,3 +97,29 @@ jobs:
         run: cargo test -vv --target wasm32-unknown-unknown
         env:
           CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUNNER: wasm-bindgen-test-runner
+
+  rustfmt:
+    name: Check Formatting
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          components: rustfmt
+
+      # Check the main crate
+      - uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+      # Check the fuzz crates
+      - uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --manifest-path fuzz/Cargo.toml -- --check
+      - uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --manifest-path fuzz-afl/Cargo.toml -- --check

benches/decoding_benchmark.rs

@@ -18,24 +18,28 @@ fn read_metadata(image: &[u8]) -> ImageInfo {
 
 fn main() {
     let mut c = Criterion::default().configure_from_args();
-    c.bench_function("decode a 512x512 JPEG", |b| b.iter(|| {
-        read_image(include_bytes!("tower.jpg"))
-    }));
-
-    c.bench_function("decode a 512x512 progressive JPEG", |b| b.iter(|| {
-        read_image(include_bytes!("tower_progressive.jpg"))
-    }));
-
-    c.bench_function("decode a 512x512 grayscale JPEG", |b| b.iter(|| {
-        read_image(include_bytes!("tower_grayscale.jpg"))
-    }));
-
-    c.bench_function("extract metadata from an image", |b| b.iter(|| {
-        read_metadata(include_bytes!("tower.jpg"))
-    }));
-
-    c.bench_function("decode a 3072x2048 RGB Lossless JPEG", |b| b.iter(|| {
-        read_image(include_bytes!("../tests/reftest/images/lossless/jpeg_lossless_sel1-rgb.jpg"))
-    }));
+    c.bench_function("decode a 512x512 JPEG", |b| {
+        b.iter(|| read_image(include_bytes!("tower.jpg")))
+    });
+
+    c.bench_function("decode a 512x512 progressive JPEG", |b| {
+        b.iter(|| read_image(include_bytes!("tower_progressive.jpg")))
+    });
+
+    c.bench_function("decode a 512x512 grayscale JPEG", |b| {
+        b.iter(|| read_image(include_bytes!("tower_grayscale.jpg")))
+    });
+
+    c.bench_function("extract metadata from an image", |b| {
+        b.iter(|| read_metadata(include_bytes!("tower.jpg")))
+    });
+
+    c.bench_function("decode a 3072x2048 RGB Lossless JPEG", |b| {
+        b.iter(|| {
+            read_image(include_bytes!(
+                "../tests/reftest/images/lossless/jpeg_lossless_sel1-rgb.jpg"
+            ))
+        })
+    });
     c.final_summary();
-}
+}

examples/decode.rs

@@ -28,26 +28,27 @@ fn main() {
         jpeg::PixelFormat::L16 => {
             encoder.set_depth(png::BitDepth::Sixteen);
             encoder.set_color(png::ColorType::Grayscale);
-        },
-        jpeg::PixelFormat::RGB24  => {
+        }
+        jpeg::PixelFormat::RGB24 => {
             encoder.set_depth(png::BitDepth::Eight);
             encoder.set_color(png::ColorType::RGB);
-        },
+        }
         jpeg::PixelFormat::CMYK32 => {
             data = cmyk_to_rgb(&mut data);
             encoder.set_depth(png::BitDepth::Eight);
             encoder.set_color(png::ColorType::RGB)
-        },
+        }
         jpeg::PixelFormat::L8 => {
             encoder.set_depth(png::BitDepth::Eight);
             encoder.set_color(png::ColorType::Grayscale);
-        },
+        }
     }
-
-    encoder.write_header()
-           .expect("writing png header failed")
-           .write_image_data(&data)
-           .expect("png encoding failed");
+
+    encoder
+        .write_header()
+        .expect("writing png header failed")
+        .write_image_data(&data)
+        .expect("png encoding failed");
 }
 
 fn cmyk_to_rgb(input: &[u8]) -> Vec<u8> {

fuzz-afl/src/reproduce_decode.rs

@@ -12,6 +12,9 @@ fn main() {
     let data = utils::read_file_from_args();
     match decode(&data) {
         Ok(bytes) => println!("Decoded {} bytes", bytes.len()),
-        Err(e) => println!("Decoder returned an error: {:?}\nNote: Not a panic, this is fine.", e),
+        Err(e) => println!(
+            "Decoder returned an error: {:?}\nNote: Not a panic, this is fine.",
+            e
+        ),
     };
 }

fuzz-afl/src/utils.rs

@@ -4,7 +4,6 @@ pub fn read_file_from_args() -> Vec<u8> {
         println!("Usage: {} <path-to-crash>", args[0]);
         std::process::exit(1);
     }
-    let data = std::fs::read(&args[1])
-        .expect(&format!("Could not open file {}", args[1]));
+    let data = std::fs::read(&args[1]).expect(&format!("Could not open file {}", args[1]));
     data
 }

fuzz/fuzz_targets/fail_tmin.rs

@@ -3,30 +3,27 @@ use libfuzzer_sys::fuzz_target;
 use std::io::{Error, Read, Write};
 use std::process::{Command, Stdio};
 
-use jpeg_decoder::Decoder;
 use image::ImageDecoder;
+use jpeg_decoder::Decoder;
 use mozjpeg::decompress::Decompress;
 
 // Try to check the image, never panic.
 fn soft_check(data: &[u8]) -> Result<Vec<u8>, Error> {
     let decompress = Decompress::new_mem(data)?;
     let mut rgb = decompress.rgb()?;
     // Yikes. That method is unsound. But we don't care, we just don't use it with UB.
-    let lines = rgb.read_scanlines::<[u8; 3]>()
+    let lines = rgb
+        .read_scanlines::<[u8; 3]>()
         .ok_or_else(|| Error::from(std::io::ErrorKind::Other))?;
-    let lines = unsafe {
-        core::slice::from_raw_parts(
-            lines.as_ptr() as *const u8,
-            lines.len()*3)
-    }.to_owned();
+    let lines =
+        unsafe { core::slice::from_raw_parts(lines.as_ptr() as *const u8, lines.len() * 3) }
+            .to_owned();
     Ok(lines)
 }
 
 fn roughly(data: &[u8], reference: &[u8]) -> bool {
-    data.len() == reference.len() && data
-        .iter()
-        .zip(reference)
-        .all(|(&o, &r)| {
+    data.len() == reference.len()
+        && data.iter().zip(reference).all(|(&o, &r)| {
             // Not the same criterion as in ref test. For some reason, mozjpeg disagrees with both
             // our output _and_ the output of djpeg/libjpeg-turbo. Let's not question this too
             // much.
@@ -61,7 +58,7 @@ fuzz_target!(|data: &[u8]| {
     // The case must have previously failed to decode, or failed reftest
     match wrong {
         Some(data) if roughly(&data, &reference) => return,
-        _ => {},
+        _ => {}
     }
 
     panic!("Success")

fuzz/fuzz_targets/regression.rs

@@ -8,7 +8,7 @@ fuzz_target!(|data: &[u8]| {
     // The case should now be fixed.
     match jpeg_decoder::Decoder::new(data).decode() {
         Err(_) => return,
-        Ok(_) => {},
+        Ok(_) => {}
     }
 
     // And error/fail on previous.

src/decoder.rs

@@ -211,18 +211,15 @@ impl<R: Read> Decoder<R> {
                 } else {
                     PreferWorkerKind::Immediate
                 }
-            },
+            }
         }
     }
 
     /// Tries to read metadata from the image without decoding it.
     ///
     /// If successful, the metadata can be obtained using the `info` method.
     pub fn read_info(&mut self) -> Result<()> {
-        WorkerScope::with(|worker| {
-            self.decode_internal(true, worker)
-        })
-        .map(|_| ())
+        WorkerScope::with(|worker| self.decode_internal(true, worker)).map(|_| ())
     }
 
     /// Configure the decoder to scale the image during decoding.
@@ -250,9 +247,7 @@ impl<R: Read> Decoder<R> {
 
     /// Decodes the image and returns the decoded pixels if successful.
     pub fn decode(&mut self) -> Result<Vec<u8>> {
-        WorkerScope::with(|worker| {
-            self.decode_internal(false, worker)
-        })
+        WorkerScope::with(|worker| self.decode_internal(false, worker))
     }
 
     fn decode_internal(
@@ -415,11 +410,13 @@ impl<R: Read> Decoder<R> {
                             }
                         }
 
-                        let preference = Self::select_worker(&frame, PreferWorkerKind::Multithreaded);
+                        let preference =
+                            Self::select_worker(&frame, PreferWorkerKind::Multithreaded);
 
-                        let (marker, data) = worker_scope.get_or_init_worker(
-                            preference,
-                            |worker| self.decode_scan(&frame, &scan, worker, &finished))?;
+                        let (marker, data) = worker_scope
+                            .get_or_init_worker(preference, |worker| {
+                                self.decode_scan(&frame, &scan, worker, &finished)
+                            })?;
 
                         if let Some(data) = data {
                             for (i, plane) in data
@@ -566,10 +563,9 @@ impl<R: Read> Decoder<R> {
         let frame = self.frame.as_ref().unwrap();
         let preference = Self::select_worker(&frame, PreferWorkerKind::Multithreaded);
 
-        worker_scope.get_or_init_worker(
-            preference,
-            |worker| self.decode_planes(worker, planes, planes_u16)
-        )
+        worker_scope.get_or_init_worker(preference, |worker| {
+            self.decode_planes(worker, planes, planes_u16)
+        })
     }
 
     fn decode_planes(

src/decoder/lossless.rs

@@ -1,10 +1,10 @@
-use std::io::Read;
 use crate::decoder::{Decoder, MAX_COMPONENTS};
 use crate::error::{Error, Result};
 use crate::huffman::HuffmanDecoder;
 use crate::marker::Marker;
 use crate::parser::Predictor;
 use crate::parser::{Component, FrameInfo, ScanInfo};
+use std::io::Read;
 
 impl<R: Read> Decoder<R> {
     /// decode_scan_lossless

src/error.rs

@@ -1,6 +1,6 @@
 use alloc::boxed::Box;
-use alloc::string::String;
 use alloc::fmt;
+use alloc::string::String;
 use core::result;
 use std::error::Error as StdError;
 use std::io::Error as IoError;
@@ -46,10 +46,10 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            Error::Format(ref desc)      => write!(f, "invalid JPEG format: {}", desc),
+            Error::Format(ref desc) => write!(f, "invalid JPEG format: {}", desc),
             Error::Unsupported(ref feat) => write!(f, "unsupported JPEG feature: {:?}", feat),
-            Error::Io(ref err)           => err.fmt(f),
-            Error::Internal(ref err)     => err.fmt(f),
+            Error::Io(ref err) => err.fmt(f),
+            Error::Internal(ref err) => err.fmt(f),
         }
     }
 }