Clippy, etc.

Author: kornelski

src/bin/ffmpeg_source.rs

@@ -1,8 +1,6 @@
 use crate::source::{Fps, Source};
-use crate::SrcPath;
-use crate::BinResult;
-use gifski::Collector;
-use gifski::Settings;
+use crate::{BinResult, SrcPath};
+use gifski::{Collector, Settings};
 use imgref::*;
 use rgb::*;
 
@@ -17,6 +15,7 @@ impl Source for FfmpegDecoder {
     fn total_frames(&self) -> Option<u64> {
         Some(self.frames)
     }
+
     fn collect(&mut self, dest: &mut Collector) -> BinResult<()> {
         self.collect_frames(dest)
     }
@@ -36,12 +35,7 @@ impl FfmpegDecoder {
         let stream = input_context.streams().best(ffmpeg::media::Type::Video).ok_or("The file has no video tracks")?;
         let time_base = stream.time_base().numerator() as f64 / stream.time_base().denominator() as f64;
         let frames = (stream.duration() as f64 * time_base * filter_fps as f64).ceil() as u64;
-        Ok(Self {
-            input_context,
-            frames,
-            rate,
-            settings,
-        })
+        Ok(Self { input_context, frames, rate, settings })
     }
 
     #[inline(never)]
@@ -76,7 +70,6 @@ impl FfmpegDecoder {
             (stream.index(), decoder, filter)
         };
 
-
         let add_frame = |rgba_frame: &ffmpeg::util::frame::Video, pts: f64, pos: i64| -> BinResult<()> {
             let stride = rgba_frame.stride(0) as usize;
             if stride % 4 != 0 {

src/bin/gif_source.rs

@@ -1,10 +1,10 @@
 //! This is for reading GIFs as an input for re-encoding as another GIF
 
-use std::io::Read;
 use crate::source::{Fps, Source};
 use crate::{BinResult, SrcPath};
 use gif::Decoder;
 use gifski::Collector;
+use std::io::Read;
 
 pub struct GifDecoder {
     speed: f32,

src/bin/gifski.rs

@@ -8,31 +8,31 @@
 #![allow(clippy::redundant_closure_for_method_calls)]
 #![allow(clippy::wildcard_imports)]
 
-use clap::error::ErrorKind::MissingRequiredArgument;
 use clap::builder::NonEmptyStringValueParser;
+use clap::error::ErrorKind::MissingRequiredArgument;
+use clap::value_parser;
+use gifski::{Repeat, Settings};
 use std::io::stdin;
 use std::io::BufRead;
 use std::io::BufReader;
 use std::io::IsTerminal;
 use std::io::Read;
 use std::io::StdinLock;
 use std::io::Stdout;
-use gifski::{Settings, Repeat};
-use clap::value_parser;
 
 #[cfg(feature = "video")]
 mod ffmpeg_source;
-mod png;
 mod gif_source;
-mod y4m_source;
+mod png;
 mod source;
+mod y4m_source;
 use crate::source::Source;
 
 use gifski::progress::{NoProgress, ProgressReporter};
 
 pub type BinResult<T, E = Box<dyn std::error::Error + Send + Sync>> = Result<T, E>;
 
-use clap::{Command, Arg, ArgAction};
+use clap::{Arg, ArgAction, Command};
 
 use std::env;
 use std::fmt;
@@ -239,8 +239,7 @@ fn bin_main() -> BinResult<()> {
 
     if fps > 100.0 || fps <= 0.0 {
         return Err("100 fps is maximum".into());
-    }
-    else if !quiet && fps > 50.0 {
+    } else if !quiet && fps > 50.0 {
         eprintln!("warning: web browsers support max 50 fps");
     }
 
@@ -285,7 +284,7 @@ fn bin_main() -> BinResult<()> {
                 }
                 SrcPath::Stdin(BufReader::new(fd))
             } else {
-                SrcPath::Path(path.to_path_buf())
+                SrcPath::Path(path.clone())
             };
             match file_type(&mut src).unwrap_or(FileType::Other) {
                 FileType::PNG | FileType::JPEG => return Err("Only a single image file was given as an input. This is not enough to make an animation.".into()),
@@ -413,7 +412,7 @@ fn panic_err(err: Box<dyn std::any::Any + Send>) -> String {
 }
 
 fn parse_color(c: &str) -> Result<rgb::RGB8, String> {
-    let c = c.trim_matches(|c:char| c.is_ascii_whitespace());
+    let c = c.trim_matches(|c: char| c.is_ascii_whitespace());
     let c = c.strip_prefix('#').unwrap_or(c);
 
     if c.len() != 6 {
@@ -429,15 +428,15 @@ fn parse_color(c: &str) -> Result<rgb::RGB8, String> {
 }
 
 fn parse_colors(colors: &str) -> Result<Vec<rgb::RGB8>, String> {
-    colors.split(|c:char| c == ' ' || c == ',')
+    colors.split([' ', ','])
         .filter(|c| !c.is_empty())
         .map(parse_color)
         .collect()
 }
 
 #[test]
 fn color_parser() {
-    assert_eq!(parse_colors("#123456 78abCD,, ,").unwrap(), vec![rgb::RGB8::new(0x12,0x34,0x56), rgb::RGB8::new(0x78,0xab,0xcd)]);
+    assert_eq!(parse_colors("#123456 78abCD,, ,").unwrap(), vec![rgb::RGB8::new(0x12, 0x34, 0x56), rgb::RGB8::new(0x78, 0xab, 0xcd)]);
     assert!(parse_colors("#12345").is_err());
 }
 
@@ -456,7 +455,7 @@ fn file_type(src: &mut SrcPath) -> BinResult<FileType> {
             _ => {
                 let mut file = std::fs::File::open(path)?;
                 file.read_exact(&mut buf)?;
-            }
+            },
         },
         SrcPath::Stdin(stdin) => {
             let buf_in = stdin.fill_buf()?;
@@ -494,18 +493,15 @@ fn check_if_paths_exist(paths: &[PathBuf]) -> BinResult<()> {
         };
         let canon = path.canonicalize();
         if let Some(parent) = canon.as_deref().unwrap_or(path).parent() {
-            if parent.as_os_str() != "" {
-                if let Ok(false) = path.try_exists() {
-                    use std::fmt::Write;
-                    if msg.len() > 80 {
-                        msg.push('\n');
-                    }
-                    write!(&mut msg, " (directory \"{}\" doesn't exist either)", parent.display())?;
-
+            if parent.as_os_str() != "" && matches!(path.try_exists(), Ok(false)) {
+                use std::fmt::Write;
+                if msg.len() > 80 {
+                    msg.push('\n');
                 }
+                write!(&mut msg, " (directory \"{}\" doesn't exist either)", parent.display())?;
             }
         }
-        if path.to_str().map_or(false, |p| p.contains(['*','?','['])) {
+        if path.to_str().is_some_and(|p| p.contains(['*', '?', '['])) {
             msg += "\nThe wildcard pattern did not match any files.";
         } else if path.is_relative() {
             use std::fmt::Write;
@@ -514,7 +510,7 @@ fn check_if_paths_exist(paths: &[PathBuf]) -> BinResult<()> {
         if path.extension() == Some("gif".as_ref()) {
             msg = format!("\nDid you mean to use -o \"{}\" to specify it as the output file instead?", path.display());
         }
-        return Err(msg.into())
+        return Err(msg.into());
     }
     Ok(())
 }
@@ -571,7 +567,7 @@ fn get_video_decoder(ftype: FileType, src: SrcPath, fps: source::Fps, _: Setting
             SrcPath::Path(path) => path,
             SrcPath::Stdin(_) => Path::new("video.mp4"),
         };
-        let rel_path = path.file_name().map(Path::new).unwrap_or(path);
+        let rel_path = path.file_name().map_or(path, Path::new);
         Err(format!(r#"Video support is permanently disabled in this distribution of gifski.
 
 The only 'video' format supported at this time is YUV4MPEG2, which can be piped from ffmpeg:
@@ -627,12 +623,12 @@ impl ProgressReporter for ProgressBar {
             let total_size = bytes * self.pb.total / self.frames;
             let new_estimate = if total_size >= self.previous_estimate { total_size } else { (self.previous_estimate + total_size) / 2 };
             self.previous_estimate = new_estimate;
-            if self.displayed_estimate.abs_diff(new_estimate) > new_estimate/10 {
+            if self.displayed_estimate.abs_diff(new_estimate) > new_estimate / 10 {
                 self.displayed_estimate = new_estimate;
                 let (num, unit, x) = if new_estimate > 1_000_000 {
-                    (new_estimate as f64/1_000_000., "MB", if new_estimate > 10_000_000 {0} else {1})
+                    (new_estimate as f64 / 1_000_000., "MB", if new_estimate > 10_000_000 { 0 } else { 1 })
                 } else {
-                    (new_estimate as f64/1_000., "KB", 0)
+                    (new_estimate as f64 / 1_000., "KB", 0)
                 };
                 self.pb.message(&format!("{num:.x$}{unit} GIF; Frame "));
             }

src/bin/png.rs

@@ -1,6 +1,4 @@
-
-use crate::source::Fps;
-use crate::source::Source;
+use crate::source::{Fps, Source};
 use crate::BinResult;
 use gifski::Collector;
 use std::path::PathBuf;
@@ -12,7 +10,10 @@ pub struct Lodecoder {
 
 impl Lodecoder {
     pub fn new(frames: Vec<PathBuf>, params: Fps) -> Self {
-        Self { frames, fps: f64::from(params.fps) * f64::from(params.speed) }
+        Self {
+            frames,
+            fps: f64::from(params.fps) * f64::from(params.speed),
+        }
     }
 }
 

src/bin/y4m_source.rs

@@ -1,12 +1,9 @@
 use std::io::BufReader;
 use std::io::Read;
 use imgref::ImgVec;
-use y4m::Colorspace;
-use y4m::Decoder;
-use y4m::ParseError;
 use gifski::Collector;
-use yuv::color::MatrixCoefficients;
-use yuv::color::Range;
+use y4m::{Colorspace, Decoder, ParseError};
+use yuv::color::{MatrixCoefficients, Range};
 use yuv::convert::RGBConvert;
 use yuv::YUV;
 use crate::{SrcPath, BinResult};
@@ -87,6 +84,7 @@ impl Source for Y4MDecoder {
             file_size.saturating_sub(self.decoder.get_raw_params().len() as _) / (w * h * d * s / 4 + 6) as u64
         })
     }
+
     fn collect(&mut self, c: &mut Collector) -> BinResult<()> {
         let fps = self.decoder.get_framerate();
         let frame_time = 1. / (fps.num as f64 / fps.den as f64);
@@ -175,8 +173,8 @@ impl Source for Y4MDecoder {
                         },
                         Samp::S2x1 => {
                             let y = y.chunks_exact(width);
-                            let u = u.chunks_exact((width+1)/2);
-                            let v = v.chunks_exact((width+1)/2);
+                            let u = u.chunks_exact(width.div_ceil(2));
+                            let v = v.chunks_exact(width.div_ceil(2));
                             if y.len() != v.len() {
                                 return bad_frame(raw_params_str);
                             }
@@ -192,8 +190,8 @@ impl Source for Y4MDecoder {
                         },
                         Samp::S2x2 => {
                             let y = y.chunks_exact(width);
-                            let u = u.chunks_exact((width+1)/2).flat_map(|r| [r, r]);
-                            let v = v.chunks_exact((width+1)/2).flat_map(|r| [r, r]);
+                            let u = u.chunks_exact(width.div_ceil(2)).flat_map(|r| [r, r]);
+                            let v = v.chunks_exact(width.div_ceil(2)).flat_map(|r| [r, r]);
                             for (y, (u, v)) in y.zip(u.zip(v)) {
                                 let u = u.iter().copied().flat_map(|x| [x, x]);
                                 let v = v.iter().copied().flat_map(|x| [x, x]);
@@ -204,7 +202,7 @@ impl Source for Y4MDecoder {
                                     }));
                             }
                         },
-                    };
+                    }
                     if out.len() != width * height {
                         return bad_frame(raw_params_str);
                     }