From d1def859fd1617b5ed7f6273ef19f63fcacd950e Mon Sep 17 00:00:00 2001
From: xenofem <xenofem@xeno.science>
Date: Sat, 1 Jul 2023 19:08:55 -0400
Subject: [PATCH] cargo clippy

---
 src/config.rs |  8 ++++----
 src/video.rs  | 54 +++++++++++++++++++++++++--------------------------
 2 files changed, 30 insertions(+), 32 deletions(-)

diff --git a/src/config.rs b/src/config.rs
index 54ab8da..2db7917 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -15,7 +15,7 @@ pub struct Config {
     pub cohost_page: String,
 }
 
-const VAR_PREFIX: &'static str = "SCREENCAP_BOT_";
+const VAR_PREFIX: &str = "SCREENCAP_BOT_";
 
 fn get_var(name: &str) -> Result<String, VarError> {
     env::var(VAR_PREFIX.to_string() + name)
@@ -24,19 +24,19 @@ fn get_var(name: &str) -> Result<String, VarError> {
 fn parse_var<E: Debug, T: FromStr<Err = E>>(name: &str) -> Result<T, VarError> {
     get_var(name).map(|s| {
         s.parse()
-            .expect(&format!("Failed to parse {}{}", VAR_PREFIX, name))
+            .unwrap_or_else(|e| panic!("Failed to parse {}{}: {:?}", VAR_PREFIX, name, e))
     })
 }
 
 fn expect_var(name: &str) -> String {
-    get_var(name).expect(&format!("{}{} must be set", VAR_PREFIX, name))
+    get_var(name).unwrap_or_else(|_| panic!("{}{} must be set", VAR_PREFIX, name))
 }
 
 pub fn load() -> Config {
     Config {
         shows_file: parse_var("SHOWS_FILE").unwrap_or(PathBuf::from("./shows.yaml")),
         global_tags: get_var("GLOBAL_TAGS")
-            .map(|s| s.split(",").map(String::from).collect())
+            .map(|s| s.split(',').map(String::from).collect())
             .unwrap_or_default(),
         post_interval: Duration::from_secs(parse_var("POST_INTERVAL").unwrap_or(6 * 3600)),
         cohost_email: expect_var("COHOST_EMAIL"),
diff --git a/src/video.rs b/src/video.rs
index 5b320dd..3c56125 100644
--- a/src/video.rs
+++ b/src/video.rs
@@ -27,33 +27,31 @@ pub fn get_video_info<P: AsRef<Path>>(
 
     let duration_secs = ctx.duration() as f64 / f64::from(ffmpeg_next::ffi::AV_TIME_BASE);
 
-    let subtitle_stream_index = subtitle_lang
-        .map(|lang| {
-            ctx.streams()
-                .filter(|stream| {
-                    ffmpeg_next::codec::context::Context::from_parameters(stream.parameters())
-                        .map(|c| c.medium())
-                        == Ok(Type::Subtitle)
-                })
-                .enumerate()
-                .filter(|(_, stream)| {
-                    let metadata = stream.metadata();
-                    if metadata.get("language") != Some(lang) {
-                        return false;
-                    }
-                    if metadata
-                        .get("title")
-                        .map(|t| SUBTITLE_FORBID_REGEX.is_match(t))
-                        == Some(true)
-                    {
-                        return false;
-                    }
-                    true
-                })
-                .min_by_key(|(_, stream)| stream.disposition().contains(Disposition::FORCED))
-                .map(|(idx, _)| idx)
-        })
-        .flatten();
+    let subtitle_stream_index = subtitle_lang.and_then(|lang| {
+        ctx.streams()
+            .filter(|stream| {
+                ffmpeg_next::codec::context::Context::from_parameters(stream.parameters())
+                    .map(|c| c.medium())
+                    == Ok(Type::Subtitle)
+            })
+            .enumerate()
+            .filter(|(_, stream)| {
+                let metadata = stream.metadata();
+                if metadata.get("language") != Some(lang) {
+                    return false;
+                }
+                if metadata
+                    .get("title")
+                    .map(|t| SUBTITLE_FORBID_REGEX.is_match(t))
+                    == Some(true)
+                {
+                    return false;
+                }
+                true
+            })
+            .min_by_key(|(_, stream)| stream.disposition().contains(Disposition::FORCED))
+            .map(|(idx, _)| idx)
+    });
 
     Ok(VideoInfo {
         duration_secs,
@@ -66,7 +64,7 @@ pub async fn take_screencap<P: AsRef<Path>>(
     timestamp_secs: f64,
     subtitle_stream_index: Option<usize>,
 ) -> std::io::Result<Vec<u8>> {
-    let ext = source.as_ref().extension().map(|s| s.to_str()).flatten();
+    let ext = source.as_ref().extension().and_then(|s| s.to_str());
     if ext != Some("mkv") && ext != Some("mp4") {
         return Err(std::io::Error::new(
             ErrorKind::Other,