cargo clippy and fmt

src/state.rs

@@ -1,19 +1,25 @@
 use std::{collections::HashMap, io::ErrorKind};
 
-use log::{info, error};
-use tokio::{fs::File, io::{AsyncReadExt, AsyncWriteExt}};
+use log::{error, info};
+use tokio::{
+    fs::File,
+    io::{AsyncReadExt, AsyncWriteExt},
+};
 
-use crate::{DownloadableFile, storage_dir};
+use crate::{storage_dir, DownloadableFile};
 
 const STATE_FILE_NAME: &str = "files.json";
 
 pub(crate) mod timestamp {
     use core::fmt;
 
-    use serde::{Serializer, Deserializer, de::Visitor};
+    use serde::{de::Visitor, Deserializer, Serializer};
     use time::OffsetDateTime;
 
-    pub(crate) fn serialize<S: Serializer>(time: &OffsetDateTime, ser: S) -> Result<S::Ok, S::Error> {
+    pub(crate) fn serialize<S: Serializer>(
+        time: &OffsetDateTime,
+        ser: S,
+    ) -> Result<S::Ok, S::Error> {
         ser.serialize_i64(time.unix_timestamp())
     }
 
@@ -31,8 +37,13 @@ pub(crate) mod timestamp {
         }
     }
 
-    pub(crate) fn deserialize<'de, D: Deserializer<'de>>(de: D) -> Result<OffsetDateTime, D::Error> {
-        Ok(OffsetDateTime::from_unix_timestamp(de.deserialize_i64(I64Visitor)?).unwrap_or_else(|_| OffsetDateTime::now_utc()))
+    pub(crate) fn deserialize<'de, D: Deserializer<'de>>(
+        de: D,
+    ) -> Result<OffsetDateTime, D::Error> {
+        Ok(
+            OffsetDateTime::from_unix_timestamp(de.deserialize_i64(I64Visitor)?)
+                .unwrap_or_else(|_| OffsetDateTime::now_utc()),
+        )
     }
 }
 
@@ -55,18 +66,24 @@ impl PersistentState {
                     let file = if let Ok(f) = File::open(storage_dir().join(&key)).await {
                         f
                     } else {
-                        error!("Unable to open file {} referenced in persistent storage", key);
+                        error!(
+                            "Unable to open file {} referenced in persistent storage",
+                            key
+                        );
                         continue;
                     };
                     let metadata = if let Ok(md) = file.metadata().await {
                         md
                     } else {
-                        error!("Unable to get metadata for file {} referenced in persistent storage", key);
+                        error!(
+                            "Unable to get metadata for file {} referenced in persistent storage",
+                            key
+                        );
                         continue;
                     };
                     if metadata.len() != info.size {
                         error!("Mismatched file size for file {} referenced in persistent storage: expected {}, found {}", key, info.size, metadata.len());
-                        continue
+                        continue;
                     }
                     filtered.insert(key, info);
                 }
@@ -83,16 +100,23 @@ impl PersistentState {
     }
 
     async fn save(&mut self) -> std::io::Result<()> {
-        File::create(storage_dir().join(STATE_FILE_NAME)).await?.write_all(&serde_json::to_vec_pretty(&self.0)?).await
+        File::create(storage_dir().join(STATE_FILE_NAME))
+            .await?
+            .write_all(&serde_json::to_vec_pretty(&self.0)?)
+            .await
     }
 
-    pub(crate) async fn add_file(&mut self, key: String, file: DownloadableFile) -> std::io::Result<()> {
+    pub(crate) async fn add_file(
+        &mut self,
+        key: String,
+        file: DownloadableFile,
+    ) -> std::io::Result<()> {
         self.0.insert(key, file);
         self.save().await
     }
 
     pub(crate) fn lookup_file(&self, key: &str) -> Option<DownloadableFile> {
-        self.0.get(key).map(|f| f.clone())
+        self.0.get(key).cloned()
     }
 
     pub(crate) async fn remove_file(&mut self, key: &str) -> std::io::Result<()> {