Make rustfmt happy

9 files changed, 1188 insertions, 528 deletions

diff --git a/src/database/mod.rs b/src/database/mod.rs
index 98c2cae..8579125 100644
--- a/src/database/mod.rs
+++ b/src/database/mod.rs
@@ -1,17 +1,17 @@
 #![warn(missing_docs)]
-use async_trait::async_trait;
-use serde::{Serialize,Deserialize};
 use crate::indieauth::User;
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
 
 mod redis;
 pub use crate::database::redis::RedisStorage;
 #[cfg(test)]
-pub use redis::tests::{RedisInstance, get_redis_instance};
+pub use redis::tests::{get_redis_instance, RedisInstance};
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
 pub struct MicropubChannel {
     pub uid: String,
-    pub name: String
+    pub name: String,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -21,14 +21,14 @@ pub enum ErrorKind {
     JsonParsing,
     NotFound,
     BadRequest,
-    Other
+    Other,
 }
 
 #[derive(Debug)]
 pub struct StorageError {
     msg: String,
     source: Option<Box<dyn std::error::Error>>,
-    kind: ErrorKind
+    kind: ErrorKind,
 }
 unsafe impl Send for StorageError {}
 unsafe impl Sync for StorageError {}
@@ -38,14 +38,16 @@ impl From<StorageError> for tide::Response {
             ErrorKind::BadRequest => 400,
             ErrorKind::NotFound => 404,
             _ => 500,
-        }).body(serde_json::json!({
+        })
+        .body(serde_json::json!({
             "error": match err.kind() {
                 ErrorKind::BadRequest => "invalid_request",
                 ErrorKind::NotFound => "not_found",
                 _ => "database_error"
             },
             "error_description": err
-        })).build()
+        }))
+        .build()
     }
 }
 impl std::error::Error for StorageError {
@@ -58,7 +60,7 @@ impl From<serde_json::Error> for StorageError {
         Self {
             msg: format!("{}", err),
             source: Some(Box::new(err)),
-            kind: ErrorKind::JsonParsing
+            kind: ErrorKind::JsonParsing,
         }
     }
 }
@@ -70,15 +72,18 @@ impl std::fmt::Display for StorageError {
             ErrorKind::PermissionDenied => write!(f, "permission denied: "),
             ErrorKind::NotFound => write!(f, "not found: "),
             ErrorKind::BadRequest => write!(f, "bad request: "),
-            ErrorKind::Other => write!(f, "generic storage layer error: ")
+            ErrorKind::Other => write!(f, "generic storage layer error: "),
         } {
             Ok(_) => write!(f, "{}", self.msg),
-            Err(err) => Err(err)
+            Err(err) => Err(err),
         }
     }
 }
 impl serde::Serialize for StorageError {
-    fn serialize<S: serde::Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
+    fn serialize<S: serde::Serializer>(
+        &self,
+        serializer: S,
+    ) -> std::result::Result<S::Ok, S::Error> {
         serializer.serialize_str(&self.to_string())
     }
 }
@@ -88,7 +93,7 @@ impl StorageError {
         StorageError {
             msg: msg.to_string(),
             source: None,
-            kind
+            kind,
         }
     }
     /// Get the kind of an error.
@@ -100,12 +105,11 @@ impl StorageError {
     }
 }
 
-
 /// A special Result type for the Micropub backing storage.
 pub type Result<T> = std::result::Result<T, StorageError>;
 
 /// A storage backend for the Micropub server.
-/// 
+///
 /// Implementations should note that all methods listed on this trait MUST be fully atomic
 /// or lock the database so that write conflicts or reading half-written data should not occur.
 #[async_trait]
@@ -117,21 +121,21 @@ pub trait Storage: Clone + Send + Sync {
     async fn get_post(&self, url: &str) -> Result<Option<serde_json::Value>>;
 
     /// Save a post to the database as an MF2-JSON structure.
-    /// 
+    ///
     /// Note that the `post` object MUST have `post["properties"]["uid"][0]` defined.
     async fn put_post<'a>(&self, post: &'a serde_json::Value) -> Result<()>;
 
     /*/// Save a post and add it to the relevant feeds listed in `post["properties"]["channel"]`.
-    /// 
-    /// Note that the `post` object MUST have `post["properties"]["uid"][0]` defined 
+    ///
+    /// Note that the `post` object MUST have `post["properties"]["uid"][0]` defined
     /// and `post["properties"]["channel"]` defined, even if it's empty.
     async fn put_and_index_post<'a>(&mut self, post: &'a serde_json::Value) -> Result<()>;*/
-    
+
     /// Modify a post using an update object as defined in the Micropub spec.
-    /// 
+    ///
     /// Note to implementors: the update operation MUST be atomic OR MUST lock the database
     /// to prevent two clients overwriting each other's changes.
-    /// 
+    ///
     /// You can assume concurrent updates will never contradict each other, since that will be dumb.
     /// The last update always wins.
     async fn update_post<'a>(&self, url: &'a str, update: serde_json::Value) -> Result<()>;
@@ -142,21 +146,27 @@ pub trait Storage: Clone + Send + Sync {
     /// Fetch a feed at `url` and return a an h-feed object containing
     /// `limit` posts after a post by url `after`, filtering the content
     /// in context of a user specified by `user` (or an anonymous user).
-    /// 
+    ///
     /// Specifically, private posts that don't include the user in the audience
     /// will be elided from the feed, and the posts containing location and not
     /// specifying post["properties"]["location-visibility"][0] == "public"
     /// will have their location data (but not check-in data) stripped.
-    /// 
+    ///
     /// This function is used as an optimization so the client, whatever it is,
     /// doesn't have to fetch posts, then realize some of them are private, and
     /// fetch more posts.
-    /// 
+    ///
     /// Note for implementors: if you use streams to fetch posts in parallel
     /// from the database, preferably make this method use a connection pool
     /// to reduce overhead of creating a database connection per post for
     /// parallel fetching.
-    async fn read_feed_with_limit<'a>(&self, url: &'a str, after: &'a Option<String>, limit: usize, user: &'a Option<String>) -> Result<Option<serde_json::Value>>;
+    async fn read_feed_with_limit<'a>(
+        &self,
+        url: &'a str,
+        after: &'a Option<String>,
+        limit: usize,
+        user: &'a Option<String>,
+    ) -> Result<Option<serde_json::Value>>;
 
     /// Deletes a post from the database irreversibly. 'nuff said. Must be idempotent.
     async fn delete_post<'a>(&self, url: &'a str) -> Result<()>;
@@ -170,9 +180,9 @@ pub trait Storage: Clone + Send + Sync {
 
 #[cfg(test)]
 mod tests {
-    use super::{Storage, MicropubChannel};
-    use serde_json::json;
     use super::redis::tests::get_redis_instance;
+    use super::{MicropubChannel, Storage};
+    use serde_json::json;
 
     async fn test_backend_basic_operations<Backend: Storage>(backend: Backend) {
         let post: serde_json::Value = json!({
@@ -191,23 +201,47 @@ mod tests {
         backend.put_post(&post).await.unwrap();
         if let Ok(Some(returned_post)) = backend.get_post(&key).await {
             assert!(returned_post.is_object());
-            assert_eq!(returned_post["type"].as_array().unwrap().len(), post["type"].as_array().unwrap().len());
-            assert_eq!(returned_post["type"].as_array().unwrap(), post["type"].as_array().unwrap());
-            let props: &serde_json::Map<String, serde_json::Value> = post["properties"].as_object().unwrap();
+            assert_eq!(
+                returned_post["type"].as_array().unwrap().len(),
+                post["type"].as_array().unwrap().len()
+            );
+            assert_eq!(
+                returned_post["type"].as_array().unwrap(),
+                post["type"].as_array().unwrap()
+            );
+            let props: &serde_json::Map<String, serde_json::Value> =
+                post["properties"].as_object().unwrap();
             for key in props.keys() {
-                assert_eq!(returned_post["properties"][key].as_array().unwrap(), post["properties"][key].as_array().unwrap())
+                assert_eq!(
+                    returned_post["properties"][key].as_array().unwrap(),
+                    post["properties"][key].as_array().unwrap()
+                )
             }
-        } else { panic!("For some reason the backend did not return the post.") }
+        } else {
+            panic!("For some reason the backend did not return the post.")
+        }
         // Check the alternative URL - it should return the same post
         if let Ok(Some(returned_post)) = backend.get_post(&alt_url).await {
             assert!(returned_post.is_object());
-            assert_eq!(returned_post["type"].as_array().unwrap().len(), post["type"].as_array().unwrap().len());
-            assert_eq!(returned_post["type"].as_array().unwrap(), post["type"].as_array().unwrap());
-            let props: &serde_json::Map<String, serde_json::Value> = post["properties"].as_object().unwrap();
+            assert_eq!(
+                returned_post["type"].as_array().unwrap().len(),
+                post["type"].as_array().unwrap().len()
+            );
+            assert_eq!(
+                returned_post["type"].as_array().unwrap(),
+                post["type"].as_array().unwrap()
+            );
+            let props: &serde_json::Map<String, serde_json::Value> =
+                post["properties"].as_object().unwrap();
             for key in props.keys() {
-                assert_eq!(returned_post["properties"][key].as_array().unwrap(), post["properties"][key].as_array().unwrap())
+                assert_eq!(
+                    returned_post["properties"][key].as_array().unwrap(),
+                    post["properties"][key].as_array().unwrap()
+                )
             }
-        } else { panic!("For some reason the backend did not return the post.") }
+        } else {
+            panic!("For some reason the backend did not return the post.")
+        }
     }
 
     async fn test_backend_get_channel_list<Backend: Storage>(backend: Backend) {
@@ -221,33 +255,61 @@ mod tests {
             "children": []
         });
         backend.put_post(&feed).await.unwrap();
-        let chans = backend.get_channels(&crate::indieauth::User::new("https://fireburn.ru/", "https://quill.p3k.io/", "create update media")).await.unwrap();
+        let chans = backend
+            .get_channels(&crate::indieauth::User::new(
+                "https://fireburn.ru/",
+                "https://quill.p3k.io/",
+                "create update media",
+            ))
+            .await
+            .unwrap();
         assert_eq!(chans.len(), 1);
-        assert_eq!(chans[0], MicropubChannel { uid: "https://fireburn.ru/feeds/main".to_string(), name: "Main Page".to_string() });
+        assert_eq!(
+            chans[0],
+            MicropubChannel {
+                uid: "https://fireburn.ru/feeds/main".to_string(),
+                name: "Main Page".to_string()
+            }
+        );
     }
 
     async fn test_backend_settings<Backend: Storage>(backend: Backend) {
-        backend.set_setting("site_name", "https://fireburn.ru/", "Vika's Hideout").await.unwrap();
-        assert_eq!(backend.get_setting("site_name", "https://fireburn.ru/").await.unwrap(), "Vika's Hideout");
+        backend
+            .set_setting("site_name", "https://fireburn.ru/", "Vika's Hideout")
+            .await
+            .unwrap();
+        assert_eq!(
+            backend
+                .get_setting("site_name", "https://fireburn.ru/")
+                .await
+                .unwrap(),
+            "Vika's Hideout"
+        );
     }
 
     #[async_std::test]
     async fn test_redis_storage_basic_operations() {
         let redis_instance = get_redis_instance().await;
-        let backend = super::RedisStorage::new(redis_instance.uri().to_string()).await.unwrap();
+        let backend = super::RedisStorage::new(redis_instance.uri().to_string())
+            .await
+            .unwrap();
         test_backend_basic_operations(backend).await;
     }
     #[async_std::test]
     async fn test_redis_storage_channel_list() {
         let redis_instance = get_redis_instance().await;
-        let backend = super::RedisStorage::new(redis_instance.uri().to_string()).await.unwrap();
+        let backend = super::RedisStorage::new(redis_instance.uri().to_string())
+            .await
+            .unwrap();
         test_backend_get_channel_list(backend).await;
     }
 
     #[async_std::test]
     async fn test_redis_settings() {
         let redis_instance = get_redis_instance().await;
-        let backend = super::RedisStorage::new(redis_instance.uri().to_string()).await.unwrap();
+        let backend = super::RedisStorage::new(redis_instance.uri().to_string())
+            .await
+            .unwrap();
         test_backend_settings(backend).await;
     }
 }
diff --git a/src/database/redis/mod.rs b/src/database/redis/mod.rs
index 352cece..5a6b70d 100644
--- a/src/database/redis/mod.rs
+++ b/src/database/redis/mod.rs
@@ -1,20 +1,20 @@
 use async_trait::async_trait;
+use futures::stream;
 use futures_util::FutureExt;
 use futures_util::StreamExt;
-use futures::stream;
 use lazy_static::lazy_static;
 use log::error;
+use mobc::Pool;
 use mobc_redis::redis;
 use mobc_redis::redis::AsyncCommands;
-use serde_json::json;
-use mobc::Pool;
 use mobc_redis::RedisConnectionManager;
+use serde_json::json;
 
-use crate::database::{Storage, Result, StorageError, ErrorKind, MicropubChannel};
+use crate::database::{ErrorKind, MicropubChannel, Result, Storage, StorageError};
 use crate::indieauth::User;
 
 struct RedisScripts {
-    edit_post: redis::Script
+    edit_post: redis::Script,
 }
 
 impl From<mobc_redis::redis::RedisError> for StorageError {
@@ -22,7 +22,7 @@ impl From<mobc_redis::redis::RedisError> for StorageError {
         Self {
             msg: format!("{}", err),
             source: Some(Box::new(err)),
-            kind: ErrorKind::Backend
+            kind: ErrorKind::Backend,
         }
     }
 }
@@ -31,7 +31,7 @@ impl From<mobc::Error<mobc_redis::redis::RedisError>> for StorageError {
         Self {
             msg: format!("{}", err),
             source: Some(Box::new(err)),
-            kind: ErrorKind::Backend
+            kind: ErrorKind::Backend,
         }
     }
 }
@@ -64,17 +64,40 @@ fn filter_post(mut post: serde_json::Value, user: &'_ Option<String>) -> Option<
         }));
     }
     let empty_vec: Vec<serde_json::Value> = vec![];
-    let author = post["properties"]["author"].as_array().unwrap_or(&empty_vec).iter().map(|i| i.as_str().unwrap().to_string());
-    let visibility = post["properties"]["visibility"][0].as_str().unwrap_or("public");
-    let mut audience = author.chain(post["properties"]["audience"].as_array().unwrap_or(&empty_vec).iter().map(|i| i.as_str().unwrap().to_string()));
-    if (visibility == "private" && !audience.any(|i| Some(i) == *user)) || (visibility == "protected" && user.is_none()) {
-        return None
+    let author = post["properties"]["author"]
+        .as_array()
+        .unwrap_or(&empty_vec)
+        .iter()
+        .map(|i| i.as_str().unwrap().to_string());
+    let visibility = post["properties"]["visibility"][0]
+        .as_str()
+        .unwrap_or("public");
+    let mut audience = author.chain(
+        post["properties"]["audience"]
+            .as_array()
+            .unwrap_or(&empty_vec)
+            .iter()
+            .map(|i| i.as_str().unwrap().to_string()),
+    );
+    if (visibility == "private" && !audience.any(|i| Some(i) == *user))
+        || (visibility == "protected" && user.is_none())
+    {
+        return None;
     }
     if post["properties"]["location"].is_array() {
-        let location_visibility = post["properties"]["location-visibility"][0].as_str().unwrap_or("private");
-        let mut author = post["properties"]["author"].as_array().unwrap_or(&empty_vec).iter().map(|i| i.as_str().unwrap().to_string());
+        let location_visibility = post["properties"]["location-visibility"][0]
+            .as_str()
+            .unwrap_or("private");
+        let mut author = post["properties"]["author"]
+            .as_array()
+            .unwrap_or(&empty_vec)
+            .iter()
+            .map(|i| i.as_str().unwrap().to_string());
         if location_visibility == "private" && !author.any(|i| Some(i) == *user) {
-            post["properties"].as_object_mut().unwrap().remove("location");
+            post["properties"]
+                .as_object_mut()
+                .unwrap()
+                .remove("location");
         }
     }
     Some(post)
@@ -84,12 +107,16 @@ fn filter_post(mut post: serde_json::Value, user: &'_ Option<String>) -> Option<
 impl Storage for RedisStorage {
     async fn get_setting<'a>(&self, setting: &'a str, user: &'a str) -> Result<String> {
         let mut conn = self.redis.get().await?;
-        Ok(conn.hget::<String, &str, String>(format!("settings_{}", user), setting).await?)
+        Ok(conn
+            .hget::<String, &str, String>(format!("settings_{}", user), setting)
+            .await?)
     }
 
     async fn set_setting<'a>(&self, setting: &'a str, user: &'a str, value: &'a str) -> Result<()> {
         let mut conn = self.redis.get().await?;
-        Ok(conn.hset::<String, &str, &str, ()>(format!("settings_{}", user), setting, value).await?)
+        Ok(conn
+            .hset::<String, &str, &str, ()>(format!("settings_{}", user), setting, value)
+            .await?)
     }
 
     async fn delete_post<'a>(&self, url: &'a str) -> Result<()> {
@@ -101,41 +128,63 @@ impl Storage for RedisStorage {
         let mut conn = self.redis.get().await?;
         Ok(conn.hexists::<&str, &str, bool>(&"posts", url).await?)
     }
-    
+
     async fn get_post(&self, url: &str) -> Result<Option<serde_json::Value>> {
         let mut conn = self.redis.get().await?;
-        match conn.hget::<&str, &str, Option<String>>(&"posts", url).await? {
+        match conn
+            .hget::<&str, &str, Option<String>>(&"posts", url)
+            .await?
+        {
             Some(val) => {
                 let parsed = serde_json::from_str::<serde_json::Value>(&val)?;
                 if let Some(new_url) = parsed["see_other"].as_str() {
-                    match conn.hget::<&str, &str, Option<String>>(&"posts", new_url).await? {
+                    match conn
+                        .hget::<&str, &str, Option<String>>(&"posts", new_url)
+                        .await?
+                    {
                         Some(val) => Ok(Some(serde_json::from_str::<serde_json::Value>(&val)?)),
-                        None => Ok(None)
+                        None => Ok(None),
                     }
                 } else {
                     Ok(Some(parsed))
                 }
-            },
-            None => Ok(None)
+            }
+            None => Ok(None),
         }
     }
 
     async fn get_channels(&self, user: &User) -> Result<Vec<MicropubChannel>> {
         let mut conn = self.redis.get().await?;
-        let channels = conn.smembers::<String, Vec<String>>("channels_".to_string() + user.me.as_str()).await?;
+        let channels = conn
+            .smembers::<String, Vec<String>>("channels_".to_string() + user.me.as_str())
+            .await?;
         // TODO: use streams here instead of this weird thing... how did I even write this?!
-        Ok(futures_util::future::join_all(channels.iter()
-            .map(|channel| self.get_post(channel)
-                .map(|result| result.unwrap())
-                .map(|post: Option<serde_json::Value>| {
-                    if let Some(post) = post {
-                        Some(MicropubChannel {
-                            uid: post["properties"]["uid"][0].as_str().unwrap().to_string(),
-                            name: post["properties"]["name"][0].as_str().unwrap().to_string()
-                        })
-                    } else { None }
+        Ok(futures_util::future::join_all(
+            channels
+                .iter()
+                .map(|channel| {
+                    self.get_post(channel).map(|result| result.unwrap()).map(
+                        |post: Option<serde_json::Value>| {
+                            if let Some(post) = post {
+                                Some(MicropubChannel {
+                                    uid: post["properties"]["uid"][0].as_str().unwrap().to_string(),
+                                    name: post["properties"]["name"][0]
+                                        .as_str()
+                                        .unwrap()
+                                        .to_string(),
+                                })
+                            } else {
+                                None
+                            }
+                        },
+                    )
                 })
-            ).collect::<Vec<_>>()).await.into_iter().filter_map(|chan| chan).collect::<Vec<_>>())
+                .collect::<Vec<_>>(),
+        )
+        .await
+        .into_iter()
+        .filter_map(|chan| chan)
+        .collect::<Vec<_>>())
     }
 
     async fn put_post<'a>(&self, post: &'a serde_json::Value) -> Result<()> {
@@ -143,72 +192,122 @@ impl Storage for RedisStorage {
         let key: &str;
         match post["properties"]["uid"][0].as_str() {
             Some(uid) => key = uid,
-            None => return Err(StorageError::new(ErrorKind::BadRequest, "post doesn't have a UID"))
+            None => {
+                return Err(StorageError::new(
+                    ErrorKind::BadRequest,
+                    "post doesn't have a UID",
+                ))
+            }
         }
-        conn.hset::<&str, &str, String, ()>(&"posts", key, post.to_string()).await?;
+        conn.hset::<&str, &str, String, ()>(&"posts", key, post.to_string())
+            .await?;
         if post["properties"]["url"].is_array() {
-            for url in post["properties"]["url"].as_array().unwrap().iter().map(|i| i.as_str().unwrap().to_string()) {
+            for url in post["properties"]["url"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .map(|i| i.as_str().unwrap().to_string())
+            {
                 if url != key {
-                    conn.hset::<&str, &str, String, ()>(&"posts", &url, json!({"see_other": key}).to_string()).await?;
+                    conn.hset::<&str, &str, String, ()>(
+                        &"posts",
+                        &url,
+                        json!({ "see_other": key }).to_string(),
+                    )
+                    .await?;
                 }
             }
         }
-        if post["type"].as_array().unwrap().iter().any(|i| i == "h-feed") {
+        if post["type"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|i| i == "h-feed")
+        {
             // This is a feed. Add it to the channels array if it's not already there.
-            conn.sadd::<String, &str, ()>("channels_".to_string() + post["properties"]["author"][0].as_str().unwrap(), key).await?
+            conn.sadd::<String, &str, ()>(
+                "channels_".to_string() + post["properties"]["author"][0].as_str().unwrap(),
+                key,
+            )
+            .await?
         }
         Ok(())
     }
 
-    async fn read_feed_with_limit<'a>(&self, url: &'a str, after: &'a Option<String>, limit: usize, user: &'a Option<String>) -> Result<Option<serde_json::Value>> {
+    async fn read_feed_with_limit<'a>(
+        &self,
+        url: &'a str,
+        after: &'a Option<String>,
+        limit: usize,
+        user: &'a Option<String>,
+    ) -> Result<Option<serde_json::Value>> {
         let mut conn = self.redis.get().await?;
         let mut feed;
-        match conn.hget::<&str, &str, Option<String>>(&"posts", url).await? {
+        match conn
+            .hget::<&str, &str, Option<String>>(&"posts", url)
+            .await?
+        {
             Some(post) => feed = serde_json::from_str::<serde_json::Value>(&post)?,
-            None => return Ok(None)
+            None => return Ok(None),
         }
         if feed["see_other"].is_string() {
-            match conn.hget::<&str, &str, Option<String>>(&"posts", feed["see_other"].as_str().unwrap()).await? {
+            match conn
+                .hget::<&str, &str, Option<String>>(&"posts", feed["see_other"].as_str().unwrap())
+                .await?
+            {
                 Some(post) => feed = serde_json::from_str::<serde_json::Value>(&post)?,
-                None => return Ok(None)
+                None => return Ok(None),
             }
         }
         if let Some(post) = filter_post(feed, user) {
             feed = post
         } else {
-            return Err(StorageError::new(ErrorKind::PermissionDenied, "specified user cannot access this post"))
+            return Err(StorageError::new(
+                ErrorKind::PermissionDenied,
+                "specified user cannot access this post",
+            ));
         }
         if feed["children"].is_array() {
             let children = feed["children"].as_array().unwrap();
             let posts_iter: Box<dyn std::iter::Iterator<Item = String> + Send>;
             // TODO: refactor this to apply the skip on the &mut iterator
             if let Some(after) = after {
-                posts_iter = Box::new(children.iter().map(|i| i.as_str().unwrap().to_string()).skip_while(move |i| i != after).skip(1));
+                posts_iter = Box::new(
+                    children
+                        .iter()
+                        .map(|i| i.as_str().unwrap().to_string())
+                        .skip_while(move |i| i != after)
+                        .skip(1),
+                );
             } else {
                 posts_iter = Box::new(children.iter().map(|i| i.as_str().unwrap().to_string()));
             }
             let posts = stream::iter(posts_iter)
                 .map(|url| async move {
                     match self.redis.get().await {
-                        Ok(mut conn) => match conn.hget::<&str, &str, Option<String>>("posts", &url).await {
-                            Ok(post) => match post {
-                                Some(post) => match serde_json::from_str::<serde_json::Value>(&post) {
-                                    Ok(post) => Some(post),
-                                    Err(err) => {
-                                        let err = StorageError::from(err);
-                                        error!("{}", err);
-                                        panic!("{}", err)
+                        Ok(mut conn) => {
+                            match conn.hget::<&str, &str, Option<String>>("posts", &url).await {
+                                Ok(post) => match post {
+                                    Some(post) => {
+                                        match serde_json::from_str::<serde_json::Value>(&post) {
+                                            Ok(post) => Some(post),
+                                            Err(err) => {
+                                                let err = StorageError::from(err);
+                                                error!("{}", err);
+                                                panic!("{}", err)
+                                            }
+                                        }
                                     }
+                                    // Happens because of a broken link (result of an improper deletion?)
+                                    None => None,
                                 },
-                                // Happens because of a broken link (result of an improper deletion?)
-                                None => None,
-                            },
-                            Err(err) => {
-                                let err = StorageError::from(err);
-                                error!("{}", err);
-                                panic!("{}", err)
+                                Err(err) => {
+                                    let err = StorageError::from(err);
+                                    error!("{}", err);
+                                    panic!("{}", err)
+                                }
                             }
-                        },
+                        }
                         // TODO: Instead of causing a panic, investigate how can you fail the whole stream
                         // Somehow fuse it maybe?
                         Err(err) => {
@@ -227,14 +326,20 @@ impl Storage for RedisStorage {
                 // Hack to unwrap the Option and sieve out broken links
                 // Broken links return None, and Stream::filter_map skips all Nones.
                 .filter_map(|post: Option<serde_json::Value>| async move { post })
-                .filter_map(|post| async move {
-                    filter_post(post, user)
-                })
+                .filter_map(|post| async move { filter_post(post, user) })
                 .take(limit);
             // TODO: Instead of catching panics, find a way to make the whole stream fail with Result<Vec<serde_json::Value>>
-            match std::panic::AssertUnwindSafe(posts.collect::<Vec<serde_json::Value>>()).catch_unwind().await {
+            match std::panic::AssertUnwindSafe(posts.collect::<Vec<serde_json::Value>>())
+                .catch_unwind()
+                .await
+            {
                 Ok(posts) => feed["children"] = json!(posts),
-                Err(_) => return Err(StorageError::new(ErrorKind::Other, "Unknown error encountered while assembling feed, see logs for more info"))
+                Err(_) => {
+                    return Err(StorageError::new(
+                        ErrorKind::Other,
+                        "Unknown error encountered while assembling feed, see logs for more info",
+                    ))
+                }
             }
         }
         return Ok(Some(feed));
@@ -242,39 +347,56 @@ impl Storage for RedisStorage {
 
     async fn update_post<'a>(&self, mut url: &'a str, update: serde_json::Value) -> Result<()> {
         let mut conn = self.redis.get().await?;
-        if !conn.hexists::<&str, &str, bool>("posts", url).await.unwrap() {
-            return Err(StorageError::new(ErrorKind::NotFound, "can't edit a non-existent post"))
+        if !conn
+            .hexists::<&str, &str, bool>("posts", url)
+            .await
+            .unwrap()
+        {
+            return Err(StorageError::new(
+                ErrorKind::NotFound,
+                "can't edit a non-existent post",
+            ));
         }
-        let post: serde_json::Value = serde_json::from_str(&conn.hget::<&str, &str, String>("posts", url).await?)?;
+        let post: serde_json::Value =
+            serde_json::from_str(&conn.hget::<&str, &str, String>("posts", url).await?)?;
         if let Some(new_url) = post["see_other"].as_str() {
             url = new_url
         }
-        Ok(SCRIPTS.edit_post.key("posts").arg(url).arg(update.to_string()).invoke_async::<_, ()>(&mut conn as &mut redis::aio::Connection).await?)
+        Ok(SCRIPTS
+            .edit_post
+            .key("posts")
+            .arg(url)
+            .arg(update.to_string())
+            .invoke_async::<_, ()>(&mut conn as &mut redis::aio::Connection)
+            .await?)
     }
 }
 
-
 impl RedisStorage {
     /// Create a new RedisDatabase that will connect to Redis at `redis_uri` to store data.
     pub async fn new(redis_uri: String) -> Result<Self> {
         match redis::Client::open(redis_uri) {
-            Ok(client) => Ok(Self { redis: Pool::builder().max_open(20).build(RedisConnectionManager::new(client)) }),
-            Err(e) => Err(e.into())
+            Ok(client) => Ok(Self {
+                redis: Pool::builder()
+                    .max_open(20)
+                    .build(RedisConnectionManager::new(client)),
+            }),
+            Err(e) => Err(e.into()),
         }
     }
 }
 
 #[cfg(test)]
 pub mod tests {
+    use mobc_redis::redis;
     use std::process;
     use std::time::Duration;
-    use mobc_redis::redis;
 
     pub struct RedisInstance {
         // We just need to hold on to it so it won't get dropped and remove the socket
         _tempdir: tempdir::TempDir,
         uri: String,
-        child: std::process::Child
+        child: std::process::Child,
     }
     impl Drop for RedisInstance {
         fn drop(&mut self) {
@@ -292,11 +414,14 @@ pub mod tests {
         let socket = tempdir.path().join("redis.sock");
         let redis_child = process::Command::new("redis-server")
             .current_dir(&tempdir)
-            .arg("--port").arg("0")
-            .arg("--unixsocket").arg(&socket)
+            .arg("--port")
+            .arg("0")
+            .arg("--unixsocket")
+            .arg(&socket)
             .stdout(process::Stdio::null())
             .stderr(process::Stdio::null())
-            .spawn().expect("Failed to spawn Redis");
+            .spawn()
+            .expect("Failed to spawn Redis");
         println!("redis+unix:///{}", socket.to_str().unwrap());
         let uri = format!("redis+unix:///{}", socket.to_str().unwrap());
         // There should be a slight delay, we need to wait for Redis to spin up
@@ -317,7 +442,9 @@ pub mod tests {
         }
 
         return RedisInstance {
-            uri, child: redis_child, _tempdir: tempdir
-        }
+            uri,
+            child: redis_child,
+            _tempdir: tempdir,
+        };
     }
 }
diff --git a/src/frontend/mod.rs b/src/frontend/mod.rs
index c92619b..eefc257 100644
--- a/src/frontend/mod.rs
+++ b/src/frontend/mod.rs
@@ -1,17 +1,17 @@
-use serde::{Serialize, Deserialize};
-use tide::{Request, Response, Result, StatusCode, Next};
-use log::{info,error};
-use crate::ApplicationState;
 use crate::database::Storage;
+use crate::ApplicationState;
+use log::{error, info};
+use serde::{Deserialize, Serialize};
+use tide::{Next, Request, Response, Result, StatusCode};
 
 static POSTS_PER_PAGE: usize = 20;
 
 mod templates {
-    use log::error;
-    use http_types::StatusCode;
-    use ellipse::Ellipse;
-    use chrono;
     use super::IndiewebEndpoints;
+    use chrono;
+    use ellipse::Ellipse;
+    use http_types::StatusCode;
+    use log::error;
 
     /// Return a pretty location specifier from a geo: URI.
     fn decode_geo_uri(uri: &str) -> String {
@@ -21,12 +21,12 @@ mod templates {
                 let lat = parts.next().unwrap();
                 let lon = parts.next().unwrap();
                 // TODO - format them as proper latitude and longitude
-                return format!("{}, {}", lat, lon)
+                return format!("{}, {}", lat, lon);
             } else {
-                return uri.to_string()
+                return uri.to_string();
             }
         } else {
-            return uri.to_string()
+            return uri.to_string();
         }
     }
 
@@ -124,7 +124,7 @@ mod templates {
                     div.form_group {
                         label[for="hcard_name"] { "Your name" }
                         input#hcard_name[name="hcard_name", placeholder="Your name"];
-                        small { 
+                        small {
                             "No need to write the name as in your passport, this is not a legal document "
                             "- just write how you want to be called on the network. This name will be also "
                             "shown whenever you leave a comment on someone else's post using your website."
@@ -165,7 +165,7 @@ mod templates {
                         small { "A little bit of introduction. Just one paragraph, and note, you can't use HTML here (yet)." }
                         // TODO: HTML e-note instead of p-note
                     }
-                    
+
                     // TODO: u-photo upload - needs media endpoint cooperation
 
                     div.switch_card_buttons {
@@ -438,7 +438,7 @@ mod templates {
                 @if card["properties"]["photo"][0].is_string() {
                     img."u-photo"[src=card["properties"]["photo"][0].as_str().unwrap()];
                 }
-                h1 { 
+                h1 {
                     a."u-url"."u-uid"."p-name"[href=card["properties"]["uid"][0].as_str().unwrap()] {
                         @card["properties"]["name"][0].as_str().unwrap()
                     }
@@ -508,7 +508,7 @@ mod templates {
                     }
                 }
                 @if feed["children"].as_array().map(|a| a.len()).unwrap_or(0) == super::POSTS_PER_PAGE {
-                    a[rel="prev", href=feed["properties"]["uid"][0].as_str().unwrap().to_string() 
+                    a[rel="prev", href=feed["properties"]["uid"][0].as_str().unwrap().to_string()
                         + "?after=" + feed["children"][super::POSTS_PER_PAGE - 1]["properties"]["uid"][0].as_str().unwrap()] {
                         "Older posts"
                     }
@@ -521,8 +521,8 @@ mod templates {
                 #dynamicstuff {
                     p { "This section will provide interesting statistics or tidbits about my life in this exact moment (with maybe a small delay)." }
                     p { "It will probably require JavaScript to self-update, but I promise to keep this widget lightweight and open-source!" }
-                    p { small { 
-                        "JavaScript isn't a menace, stop fearing it or I will switch to WebAssembly " 
+                    p { small {
+                        "JavaScript isn't a menace, stop fearing it or I will switch to WebAssembly "
                         "and knock your nico-nico-kneecaps so fast with its speed you won't even notice that... "
                         small { "omae ha mou shindeiru" }
                         // NANI?!!!
@@ -557,7 +557,7 @@ mod templates {
                 StatusCode::ImATeapot => {
                     p { "Wait, do you seriously expect my website to brew you coffee? It's not a coffee machine!" }
 
-                    p { 
+                    p {
                         small { "I could brew you some coffee tho if we meet one day... "
                         small { i { "i-it's nothing personal, I just like brewing coffee, b-baka!!!~ >.<!" } } }
                     }
@@ -565,51 +565,61 @@ mod templates {
                 _ => { p { "It seems like you have found an error. Not to worry, it has already been logged." } }
             }
             P { "For now, may I suggest to visit " a[href="/"] {"the main page"} " of this website?" }
-        
+
         }
     }
 }
 
-use templates::{Template,ErrorPage,MainPage,OnboardingPage};
+use templates::{ErrorPage, MainPage, OnboardingPage, Template};
 
 #[derive(Clone, Serialize, Deserialize)]
 pub struct IndiewebEndpoints {
     authorization_endpoint: String,
     token_endpoint: String,
     webmention: Option<String>,
-    microsub: Option<String>
+    microsub: Option<String>,
 }
 
 #[derive(Deserialize)]
 struct QueryParams {
-    after: Option<String>
+    after: Option<String>,
 }
 
 #[derive(Debug)]
 struct FrontendError {
     msg: String,
     source: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
-    code: StatusCode
+    code: StatusCode,
 }
 impl FrontendError {
     pub fn with_code(code: StatusCode, msg: &str) -> Self {
-        Self { msg: msg.to_string(), source: None, code }
+        Self {
+            msg: msg.to_string(),
+            source: None,
+            code,
+        }
+    }
+    pub fn msg(&self) -> &str {
+        &self.msg
+    }
+    pub fn code(&self) -> StatusCode {
+        self.code
     }
-    pub fn msg(&self) -> &str { &self.msg }
-    pub fn code(&self) -> StatusCode { self.code }
 }
 impl From<crate::database::StorageError> for FrontendError {
     fn from(err: crate::database::StorageError) -> Self {
         Self {
             msg: "Database error".to_string(),
             source: Some(Box::new(err)),
-            code: StatusCode::InternalServerError
+            code: StatusCode::InternalServerError,
         }
     }
 }
 impl std::error::Error for FrontendError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        self.source.as_ref().map(|e| e.as_ref() as &(dyn std::error::Error + 'static))
+        self.source
+            .as_ref()
+            .map(|e| e.as_ref() as &(dyn std::error::Error + 'static))
     }
 }
 impl std::fmt::Display for FrontendError {
@@ -618,30 +628,47 @@ impl std::fmt::Display for FrontendError {
     }
 }
 
-async fn get_post_from_database<S: Storage>(db: &S, url: &str, after: Option<String>, user: &Option<String>) -> std::result::Result<serde_json::Value, FrontendError> {
-    match db.read_feed_with_limit(url, &after, POSTS_PER_PAGE, user).await {
+async fn get_post_from_database<S: Storage>(
+    db: &S,
+    url: &str,
+    after: Option<String>,
+    user: &Option<String>,
+) -> std::result::Result<serde_json::Value, FrontendError> {
+    match db
+        .read_feed_with_limit(url, &after, POSTS_PER_PAGE, user)
+        .await
+    {
         Ok(result) => match result {
             Some(post) => Ok(post),
-            None => Err(FrontendError::with_code(StatusCode::NotFound, "Post not found in the database"))
+            None => Err(FrontendError::with_code(
+                StatusCode::NotFound,
+                "Post not found in the database",
+            )),
         },
         Err(err) => match err.kind() {
             crate::database::ErrorKind::PermissionDenied => {
                 // TODO: Authentication
                 if user.is_some() {
-                    Err(FrontendError::with_code(StatusCode::Forbidden, "User authenticated AND forbidden to access this resource"))
+                    Err(FrontendError::with_code(
+                        StatusCode::Forbidden,
+                        "User authenticated AND forbidden to access this resource",
+                    ))
                 } else {
-                    Err(FrontendError::with_code(StatusCode::Unauthorized, "User needs to authenticate themselves"))
+                    Err(FrontendError::with_code(
+                        StatusCode::Unauthorized,
+                        "User needs to authenticate themselves",
+                    ))
                 }
             }
-            _ => Err(err.into())
-        }
+            _ => Err(err.into()),
+        },
     }
 }
 
 #[derive(Deserialize)]
 struct OnboardingFeed {
     slug: String,
-    name: String
+    name: String,
 }
 
 #[derive(Deserialize)]
@@ -649,7 +676,7 @@ struct OnboardingData {
     user: serde_json::Value,
     first_post: serde_json::Value,
     blog_name: String,
-    feeds: Vec<OnboardingFeed>
+    feeds: Vec<OnboardingFeed>,
 }
 
 pub async fn onboarding_receiver<S: Storage>(mut req: Request<ApplicationState<S>>) -> Result {
@@ -663,16 +690,24 @@ pub async fn onboarding_receiver<S: Storage>(mut req: Request<ApplicationState<S
     let me = url::Url::parse("http://localhost:8080/").unwrap();
 
     if let Ok(_) = get_post_from_database(backend, me.as_str(), None, &None).await {
-        Err(FrontendError::with_code(StatusCode::Forbidden, "Onboarding is over. Are you trying to take over somebody's website?!"))?
+        Err(FrontendError::with_code(
+            StatusCode::Forbidden,
+            "Onboarding is over. Are you trying to take over somebody's website?!",
+        ))?
     }
     info!("Onboarding new user: {}", me);
 
     let user = crate::indieauth::User::new(me.as_str(), "https://kittybox.fireburn.ru/", "create");
 
-    backend.set_setting("site_name", user.me.as_str(), &body.blog_name).await?;
+    backend
+        .set_setting("site_name", user.me.as_str(), &body.blog_name)
+        .await?;
 
     if body.user["type"][0] != "h-card" || body.first_post["type"][0] != "h-entry" {
-        Err(FrontendError::with_code(StatusCode::BadRequest, "user and first_post should be h-card and h-entry"))?
+        Err(FrontendError::with_code(
+            StatusCode::BadRequest,
+            "user and first_post should be h-card and h-entry",
+        ))?
     }
     info!("Validated body.user and body.first_post as microformats2");
 
@@ -680,7 +715,7 @@ pub async fn onboarding_receiver<S: Storage>(mut req: Request<ApplicationState<S
     let hentry = body.first_post;
 
     // Ensure the h-card's UID is set to the main page, so it will be fetchable.
-    hcard["properties"]["uid"] = json!([ me.as_str() ]);
+    hcard["properties"]["uid"] = json!([me.as_str()]);
     // Normalize the h-card - note that it should preserve the UID we set here.
     let (_, hcard) = crate::micropub::normalize_mf2(hcard, &user);
     // The h-card is written directly - all the stuff in the Micropub's
@@ -690,10 +725,13 @@ pub async fn onboarding_receiver<S: Storage>(mut req: Request<ApplicationState<S
     backend.put_post(&hcard).await?;
 
     for feed in body.feeds {
-        let (_, feed) = crate::micropub::normalize_mf2(json!({
-            "type": ["h-feed"],
-            "properties": {"name": [feed.name], "mp-slug": [feed.slug]}
-        }), &user);
+        let (_, feed) = crate::micropub::normalize_mf2(
+            json!({
+                "type": ["h-feed"],
+                "properties": {"name": [feed.name], "mp-slug": [feed.slug]}
+            }),
+            &user,
+        );
 
         backend.put_post(&feed).await?;
     }
@@ -707,8 +745,11 @@ pub async fn onboarding_receiver<S: Storage>(mut req: Request<ApplicationState<S
 }
 
 pub async fn coffee<S: Storage>(_: Request<ApplicationState<S>>) -> Result {
-    Err(FrontendError::with_code(StatusCode::ImATeapot, "Someone asked this website to brew them some coffee..."))?;
-    return Ok(Response::builder(500).build()) // unreachable
+    Err(FrontendError::with_code(
+        StatusCode::ImATeapot,
+        "Someone asked this website to brew them some coffee...",
+    ))?;
+    return Ok(Response::builder(500).build()); // unreachable
 }
 
 pub async fn mainpage<S: Storage>(req: Request<ApplicationState<S>>) -> Result {
@@ -726,7 +767,7 @@ pub async fn mainpage<S: Storage>(req: Request<ApplicationState<S>>) -> Result {
     info!("Request at {}", url);
     let hcard_url = url.as_str();
     let feed_url = url.join("feeds/main").unwrap().to_string();
-    
+
     let card = get_post_from_database(backend, hcard_url, None, &user).await;
     let feed = get_post_from_database(backend, &feed_url, query.after, &user).await;
 
@@ -737,34 +778,51 @@ pub async fn mainpage<S: Storage>(req: Request<ApplicationState<S>>) -> Result {
         let feed_err = feed.unwrap_err();
         if card_err.code == 404 {
             // Yes, we definitely need some onboarding here.
-            Ok(Response::builder(200).content_type("text/html; charset=utf-8").body(Template { 
-                title: "Kittybox - Onboarding",
-                blog_name: "Kitty Box!",
-                endpoints: IndiewebEndpoints {
-                  authorization_endpoint, token_endpoint,
-                  webmention: None, microsub: None
-                },
-                content: OnboardingPage {}.to_string()
-            }.to_string()).build())
+            Ok(Response::builder(200)
+                .content_type("text/html; charset=utf-8")
+                .body(
+                    Template {
+                        title: "Kittybox - Onboarding",
+                        blog_name: "Kitty Box!",
+                        endpoints: IndiewebEndpoints {
+                            authorization_endpoint,
+                            token_endpoint,
+                            webmention: None,
+                            microsub: None,
+                        },
+                        content: OnboardingPage {}.to_string(),
+                    }
+                    .to_string(),
+                )
+                .build())
         } else {
             Err(feed_err)?
         }
     } else {
         Ok(Response::builder(200)
             .content_type("text/html; charset=utf-8")
-            .body(Template {
-                title: &format!("{} - Main page", url.host().unwrap().to_string()),
-                blog_name: &backend.get_setting("site_name", &url.host().unwrap().to_string()).await.unwrap_or_else(|_| "Kitty Box!".to_string()),
-                endpoints: IndiewebEndpoints {
-                  authorization_endpoint, token_endpoint,
-                  webmention: None, microsub: None
-                },
-                content: MainPage {
-                    feed: &feed?,
-                    card: &card?
-                }.to_string()
-            }.to_string()
-        ).build())
+            .body(
+                Template {
+                    title: &format!("{} - Main page", url.host().unwrap().to_string()),
+                    blog_name: &backend
+                        .get_setting("site_name", &url.host().unwrap().to_string())
+                        .await
+                        .unwrap_or_else(|_| "Kitty Box!".to_string()),
+                    endpoints: IndiewebEndpoints {
+                        authorization_endpoint,
+                        token_endpoint,
+                        webmention: None,
+                        microsub: None,
+                    },
+                    content: MainPage {
+                        feed: &feed?,
+                        card: &card?,
+                    }
+                    .to_string(),
+                }
+                .to_string(),
+            )
+            .build())
     }
 }
 
@@ -777,41 +835,73 @@ pub async fn render_post<S: Storage>(req: Request<ApplicationState<S>>) -> Resul
     #[cfg(any(not(debug_assertions), test))]
     let url = req.url();
     #[cfg(all(debug_assertions, not(test)))]
-    let url = url::Url::parse("http://localhost:8080/").unwrap().join(req.url().path()).unwrap();
-
-    let post = get_post_from_database(&req.state().storage, url.as_str(), query.after, &user).await?;
-
-    let template: String = match post["type"][0].as_str().expect("Empty type array or invalid type") {
+    let url = url::Url::parse("http://localhost:8080/")
+        .unwrap()
+        .join(req.url().path())
+        .unwrap();
+
+    let post =
+        get_post_from_database(&req.state().storage, url.as_str(), query.after, &user).await?;
+
+    let template: String = match post["type"][0]
+        .as_str()
+        .expect("Empty type array or invalid type")
+    {
         "h-entry" => templates::Entry { post: &post }.to_string(),
         "h-card" => templates::VCard { card: &post }.to_string(),
         "h-feed" => templates::Feed { feed: &post }.to_string(),
-        _ => Err(FrontendError::with_code(StatusCode::InternalServerError, "Couldn't render an unknown type"))?
+        _ => Err(FrontendError::with_code(
+            StatusCode::InternalServerError,
+            "Couldn't render an unknown type",
+        ))?,
     };
 
     Ok(Response::builder(200)
         .content_type("text/html; charset=utf-8")
-        .body(Template {
-            title: post["properties"]["name"][0].as_str().unwrap_or(&format!("Note at {}", url.host().unwrap().to_string())),
-            blog_name: &req.state().storage.get_setting("site_name", &url.host().unwrap().to_string()).await.unwrap_or_else(|_| "Kitty Box!".to_string()),
-            endpoints: IndiewebEndpoints {
-                authorization_endpoint, token_endpoint,
-                webmention: None, microsub: None
-            },
-            content: template
-        }.to_string()
-    ).build())
+        .body(
+            Template {
+                title: post["properties"]["name"][0]
+                    .as_str()
+                    .unwrap_or(&format!("Note at {}", url.host().unwrap().to_string())),
+                blog_name: &req
+                    .state()
+                    .storage
+                    .get_setting("site_name", &url.host().unwrap().to_string())
+                    .await
+                    .unwrap_or_else(|_| "Kitty Box!".to_string()),
+                endpoints: IndiewebEndpoints {
+                    authorization_endpoint,
+                    token_endpoint,
+                    webmention: None,
+                    microsub: None,
+                },
+                content: template,
+            }
+            .to_string(),
+        )
+        .build())
 }
 
 pub struct ErrorHandlerMiddleware {}
 
 #[async_trait::async_trait]
-impl<S> tide::Middleware<ApplicationState<S>> for ErrorHandlerMiddleware where
-    S: crate::database::Storage
+impl<S> tide::Middleware<ApplicationState<S>> for ErrorHandlerMiddleware
+where
+    S: crate::database::Storage,
 {
-    async fn handle(&self, request: Request<ApplicationState<S>>, next: Next<'_, ApplicationState<S>>) -> Result {
+    async fn handle(
+        &self,
+        request: Request<ApplicationState<S>>,
+        next: Next<'_, ApplicationState<S>>,
+    ) -> Result {
         let authorization_endpoint = request.state().authorization_endpoint.to_string();
         let token_endpoint = request.state().token_endpoint.to_string();
-        let site_name = &request.state().storage.get_setting("site_name", &request.url().host().unwrap().to_string()).await.unwrap_or_else(|_| "Kitty Box!".to_string());
+        let site_name = &request
+            .state()
+            .storage
+            .get_setting("site_name", &request.url().host().unwrap().to_string())
+            .await
+            .unwrap_or_else(|_| "Kitty Box!".to_string());
         let mut res = next.run(request).await;
         let mut code: Option<StatusCode> = None;
         if let Some(err) = res.downcast_error::<FrontendError>() {
@@ -826,15 +916,20 @@ impl<S> tide::Middleware<ApplicationState<S>> for ErrorHandlerMiddleware where
         if let Some(code) = code {
             res.set_status(code);
             res.set_content_type("text/html; charset=utf-8");
-            res.set_body(Template {
-                title: "Error",
-                blog_name: site_name,
-                endpoints: IndiewebEndpoints {
-                    authorization_endpoint, token_endpoint,
-                    webmention: None, microsub: None
-                },
-                content: ErrorPage { code }.to_string()
-            }.to_string());
+            res.set_body(
+                Template {
+                    title: "Error",
+                    blog_name: site_name,
+                    endpoints: IndiewebEndpoints {
+                        authorization_endpoint,
+                        token_endpoint,
+                        webmention: None,
+                        microsub: None,
+                    },
+                    content: ErrorPage { code }.to_string(),
+                }
+                .to_string(),
+            );
         }
         Ok(res)
     }
@@ -858,7 +953,10 @@ pub async fn handle_static<S: Storage>(req: Request<ApplicationState<S>>) -> Res
             .content_type("text/css; charset=utf-8")
             .body(ONBOARDING_CSS)
             .build()),
-        Ok(_) => Err(FrontendError::with_code(StatusCode::NotFound, "Static file not found")),
-        Err(_) => panic!("Invalid usage of the frontend::handle_static() function")
+        Ok(_) => Err(FrontendError::with_code(
+            StatusCode::NotFound,
+            "Static file not found",
+        )),
+        Err(_) => panic!("Invalid usage of the frontend::handle_static() function"),
     }?)
 }
diff --git a/src/indieauth.rs b/src/indieauth.rs
index 27a70a1..f6bac04 100644
--- a/src/indieauth.rs
+++ b/src/indieauth.rs
@@ -1,11 +1,11 @@
 use async_trait::async_trait;
 #[allow(unused_imports)]
-use log::{error,info};
-use url::Url;
+use log::{error, info};
+use std::sync::Arc;
 use tide::prelude::*;
 #[allow(unused_imports)]
-use tide::{Request, Response, Next, Result};
-use std::sync::Arc;
+use tide::{Next, Request, Response, Result};
+use url::Url;
 
 use crate::database;
 use crate::ApplicationState;
@@ -14,7 +14,7 @@ use crate::ApplicationState;
 pub struct User {
     pub me: Url,
     pub client_id: Url,
-    scope: String
+    scope: String,
 }
 
 impl User {
@@ -28,23 +28,40 @@ impl User {
         Self {
             me: Url::parse(me).unwrap(),
             client_id: Url::parse(client_id).unwrap(),
-            scope: scope.to_string()
+            scope: scope.to_string(),
         }
     }
 }
 
 #[cfg(any(not(debug_assertions), test))]
-async fn get_token_data(token: String, token_endpoint: &http_types::Url, http_client: &surf::Client) -> (http_types::StatusCode, Option<User>) {
-    match http_client.get(token_endpoint).header("Authorization", token).header("Accept", "application/json").send().await {
+async fn get_token_data(
+    token: String,
+    token_endpoint: &http_types::Url,
+    http_client: &surf::Client,
+) -> (http_types::StatusCode, Option<User>) {
+    match http_client
+        .get(token_endpoint)
+        .header("Authorization", token)
+        .header("Accept", "application/json")
+        .send()
+        .await
+    {
         Ok(mut resp) => {
             if resp.status() == 200 {
                 match resp.body_json::<User>().await {
                     Ok(user) => {
-                        info!("Token endpoint request successful. Validated user: {}", user.me);
+                        info!(
+                            "Token endpoint request successful. Validated user: {}",
+                            user.me
+                        );
                         (resp.status(), Some(user))
-                    },
+                    }
                     Err(err) => {
-                        error!("Token endpoint parsing error (HTTP status {}): {}", resp.status(), err);
+                        error!(
+                            "Token endpoint parsing error (HTTP status {}): {}",
+                            resp.status(),
+                            err
+                        );
                         (http_types::StatusCode::InternalServerError, None)
                     }
                 }
@@ -63,7 +80,7 @@ async fn get_token_data(token: String, token_endpoint: &http_types::Url, http_cl
 pub struct IndieAuthMiddleware {
     #[allow(dead_code)] // it's not really dead since it's only dead in debug scope
     cache: Arc<retainer::Cache<String, User>>,
-    monitor_task: Option<async_std::task::JoinHandle<()>>
+    monitor_task: Option<async_std::task::JoinHandle<()>>,
 }
 impl IndieAuthMiddleware {
     /// Create a new instance of IndieAuthMiddleware.
@@ -74,12 +91,19 @@ impl IndieAuthMiddleware {
     pub fn new() -> Self {
         let cache: Arc<retainer::Cache<String, User>> = Arc::new(retainer::Cache::new());
         let cache_clone = cache.clone();
-        let task = async_std::task::spawn(async move { cache_clone.monitor(4, 0.1, std::time::Duration::from_secs(30)).await });
+        let task = async_std::task::spawn(async move {
+            cache_clone
+                .monitor(4, 0.1, std::time::Duration::from_secs(30))
+                .await
+        });
 
         #[cfg(all(debug_assertions, not(test)))]
         error!("ATTENTION: You are running in debug mode. NO REQUESTS TO TOKEN ENDPOINT WILL BE MADE. YOU WILL BE PROCEEDING WITH DEBUG USER CREDENTIALS. DO NOT RUN LIKE THIS IN PRODUCTION.");
 
-        Self { cache, monitor_task: Some(task) }
+        Self {
+            cache,
+            monitor_task: Some(task),
+        }
     }
 }
 impl Drop for IndieAuthMiddleware {
@@ -96,7 +120,8 @@ impl Drop for IndieAuthMiddleware {
         // (it is safe tho cuz None is no nullptr and dereferencing it doesn't cause unsafety)
         // (could cause a VERY FUNNY race condition to occur though
         //  if you tried to refer to the value in another thread!)
-        let task = std::mem::take(&mut self.monitor_task).expect("Dropped IndieAuthMiddleware TWICE? Impossible!");
+        let task = std::mem::take(&mut self.monitor_task)
+            .expect("Dropped IndieAuthMiddleware TWICE? Impossible!");
         // Then cancel the task, using another task to request cancellation.
         // Because apparently you can't run async code from Drop...
         // This should drop the last reference for the [`cache`],
@@ -105,27 +130,41 @@ impl Drop for IndieAuthMiddleware {
     }
 }
 #[async_trait]
-impl<B> tide::Middleware<ApplicationState<B>> for IndieAuthMiddleware where
-    B: database::Storage + Send + Sync + Clone
+impl<B> tide::Middleware<ApplicationState<B>> for IndieAuthMiddleware
+where
+    B: database::Storage + Send + Sync + Clone,
 {
-
     #[cfg(all(not(test), debug_assertions))]
-    async fn handle(&self, mut req: Request<ApplicationState<B>>, next: Next<'_, ApplicationState<B>>) -> Result {
-        req.set_ext(User::new("http://localhost:8080/", "https://curl.haxx.se/","create update delete undelete media"));
+    async fn handle(
+        &self,
+        mut req: Request<ApplicationState<B>>,
+        next: Next<'_, ApplicationState<B>>,
+    ) -> Result {
+        req.set_ext(User::new(
+            "http://localhost:8080/",
+            "https://curl.haxx.se/",
+            "create update delete undelete media",
+        ));
         Ok(next.run(req).await)
     }
     #[cfg(any(not(debug_assertions), test))]
-    async fn handle(&self, mut req: Request<ApplicationState<B>>, next: Next<'_, ApplicationState<B>>) -> Result {
+    async fn handle(
+        &self,
+        mut req: Request<ApplicationState<B>>,
+        next: Next<'_, ApplicationState<B>>,
+    ) -> Result {
         let header = req.header("Authorization");
         match header {
             None => {
                 // TODO: move that to the request handling functions
                 // or make a middleware that refuses to accept unauthenticated requests
-                Ok(Response::builder(401).body(json!({
-                    "error": "unauthorized",
-                    "error_description": "Please provide an access token."
-                })).build())
-            },
+                Ok(Response::builder(401)
+                    .body(json!({
+                        "error": "unauthorized",
+                        "error_description": "Please provide an access token."
+                    }))
+                    .build())
+            }
             Some(value) => {
                 let endpoint = &req.state().token_endpoint;
                 let http_client = &req.state().http_client;
@@ -177,9 +216,13 @@ mod tests {
     use super::*;
     #[test]
     fn user_scopes_are_checkable() {
-        let user = User::new("https://fireburn.ru/", "https://quill.p3k.io/", "create update media");
+        let user = User::new(
+            "https://fireburn.ru/",
+            "https://quill.p3k.io/",
+            "create update media",
+        );
 
         assert!(user.check_scope("create"));
         assert!(!user.check_scope("delete"));
     }
-}
\ No newline at end of file
+}
diff --git a/src/lib.rs b/src/lib.rs
index 27adc1a..d1bff68 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,22 +1,22 @@
 use tide::{Request, Response};
 
 mod database;
+mod frontend;
 mod indieauth;
 mod micropub;
-mod frontend;
 
 use crate::indieauth::IndieAuthMiddleware;
 
 #[derive(Clone)]
 pub struct ApplicationState<StorageBackend>
 where
-    StorageBackend: database::Storage + Send + Sync + 'static
+    StorageBackend: database::Storage + Send + Sync + 'static,
 {
     token_endpoint: surf::Url,
     authorization_endpoint: surf::Url,
     media_endpoint: Option<String>,
     http_client: surf::Client,
-    storage: StorageBackend
+    storage: StorageBackend,
 }
 
 type App<Storage> = tide::Server<ApplicationState<Storage>>;
@@ -25,70 +25,105 @@ static MICROPUB_CLIENT: &[u8] = include_bytes!("./index.html");
 
 fn equip_app<Storage>(mut app: App<Storage>) -> App<Storage>
 where
-    Storage: database::Storage + Send + Sync + Clone
+    Storage: database::Storage + Send + Sync + Clone,
 {
-    app.at("/micropub").with(IndieAuthMiddleware::new())
+    app.at("/micropub")
+        .with(IndieAuthMiddleware::new())
         .get(micropub::get_handler)
         .post(micropub::post_handler);
     // The Micropub client. It'll start small, but could grow into something full-featured!
     app.at("/micropub/client").get(|_: Request<_>| async move {
-        Ok(Response::builder(200).body(MICROPUB_CLIENT).content_type("text/html").build())
+        Ok(Response::builder(200)
+            .body(MICROPUB_CLIENT)
+            .content_type("text/html")
+            .build())
     });
-    app.at("/").with(frontend::ErrorHandlerMiddleware {})
+    app.at("/")
+        .with(frontend::ErrorHandlerMiddleware {})
         .get(frontend::mainpage)
         .post(frontend::onboarding_receiver);
-    app.at("/static/*path").with(frontend::ErrorHandlerMiddleware {}).get(frontend::handle_static);
-    app.at("/*path").with(frontend::ErrorHandlerMiddleware {}).get(frontend::render_post);
-    app.at("/coffee").with(frontend::ErrorHandlerMiddleware {}).get(frontend::coffee);
+    app.at("/static/*path")
+        .with(frontend::ErrorHandlerMiddleware {})
+        .get(frontend::handle_static);
+    app.at("/*path")
+        .with(frontend::ErrorHandlerMiddleware {})
+        .get(frontend::render_post);
+    app.at("/coffee")
+        .with(frontend::ErrorHandlerMiddleware {})
+        .get(frontend::coffee);
     app.at("/health").get(|_| async { Ok("OK") });
 
     app
 }
 
-pub async fn get_app_with_redis(token_endpoint: surf::Url, authorization_endpoint: surf::Url, redis_uri: String, media_endpoint: Option<String>) -> App<database::RedisStorage> {
-    let app = tide::with_state(ApplicationState { 
-        token_endpoint, media_endpoint,
+pub async fn get_app_with_redis(
+    token_endpoint: surf::Url,
+    authorization_endpoint: surf::Url,
+    redis_uri: String,
+    media_endpoint: Option<String>,
+) -> App<database::RedisStorage> {
+    let app = tide::with_state(ApplicationState {
+        token_endpoint,
+        media_endpoint,
         authorization_endpoint,
         storage: database::RedisStorage::new(redis_uri).await.unwrap(),
         http_client: surf::Client::new(),
     });
-    
+
     equip_app(app)
 }
 
 #[cfg(test)]
-pub async fn get_app_with_test_redis(token_endpoint: surf::Url) -> (database::RedisInstance, database::RedisStorage, App<database::RedisStorage>) {
+pub async fn get_app_with_test_redis(
+    token_endpoint: surf::Url,
+) -> (
+    database::RedisInstance,
+    database::RedisStorage,
+    App<database::RedisStorage>,
+) {
     use surf::Url;
 
     let redis_instance = database::get_redis_instance().await;
-    let backend = database::RedisStorage::new(redis_instance.uri().to_string()).await.unwrap();
+    let backend = database::RedisStorage::new(redis_instance.uri().to_string())
+        .await
+        .unwrap();
     let app = tide::with_state(ApplicationState {
-        token_endpoint, media_endpoint: None,
+        token_endpoint,
+        media_endpoint: None,
         authorization_endpoint: Url::parse("https://indieauth.com/auth").unwrap(),
         storage: backend.clone(),
         http_client: surf::Client::new(),
     });
-    return (redis_instance, backend, equip_app(app))
+    return (redis_instance, backend, equip_app(app));
 }
 
 #[cfg(test)]
 #[allow(unused_variables)]
 mod tests {
     use super::*;
+    use database::Storage;
+    use mockito::mock;
     use serde_json::json;
     use tide_testing::TideTestingExt;
-    use mockito::mock;
-    use database::Storage;
 
     // Helpers
-    async fn create_app() -> (database::RedisStorage, App<database::RedisStorage>, database::RedisInstance) {
+    async fn create_app() -> (
+        database::RedisStorage,
+        App<database::RedisStorage>,
+        database::RedisInstance,
+    ) {
         //get_app_with_memory_for_testing(surf::Url::parse(&*mockito::server_url()).unwrap()).await
-        let (r, b, a) = get_app_with_test_redis(surf::Url::parse(&*mockito::server_url()).unwrap()).await;
+        let (r, b, a) =
+            get_app_with_test_redis(surf::Url::parse(&*mockito::server_url()).unwrap()).await;
         (b, a, r)
     }
 
-    async fn post_json(app: &App<database::RedisStorage>, json: serde_json::Value) -> surf::Response {
-        let request = app.post("/micropub")
+    async fn post_json(
+        app: &App<database::RedisStorage>,
+        json: serde_json::Value,
+    ) -> surf::Response {
+        let request = app
+            .post("/micropub")
             .header("Authorization", "Bearer test")
             .header("Content-Type", "application/json")
             .body(json);
@@ -105,22 +140,30 @@ mod tests {
 
         let (db, app, _r) = create_app().await;
 
-        let response = post_json(&app, json!({
-            "type": ["h-entry"],
-            "properties": {
-                "content": ["Fake news about Aaron Parecki!"],
-                "uid": ["https://aaronparecki.com/posts/fake-news"]
-            }
-        })).await;
+        let response = post_json(
+            &app,
+            json!({
+                "type": ["h-entry"],
+                "properties": {
+                    "content": ["Fake news about Aaron Parecki!"],
+                    "uid": ["https://aaronparecki.com/posts/fake-news"]
+                }
+            }),
+        )
+        .await;
         assert_eq!(response.status(), 403);
 
-        let response = post_json(&app, json!({
-            "type": ["h-entry"],
-            "properties": {
-                "content": ["More fake news about Aaron Parecki!"],
-                "url": ["https://aaronparecki.com/posts/more-fake-news"]
-            }
-        })).await;
+        let response = post_json(
+            &app,
+            json!({
+                "type": ["h-entry"],
+                "properties": {
+                    "content": ["More fake news about Aaron Parecki!"],
+                    "url": ["https://aaronparecki.com/posts/more-fake-news"]
+                }
+            }),
+        )
+        .await;
         assert_eq!(response.status(), 403);
 
         let response = post_json(&app, json!({
@@ -143,9 +186,12 @@ mod tests {
 
         let (db, app, _r) = create_app().await;
 
-        let response: serde_json::Value = app.get("/micropub?q=config")
+        let response: serde_json::Value = app
+            .get("/micropub?q=config")
             .header("Authorization", "test")
-            .recv_json().await.unwrap();
+            .recv_json()
+            .await
+            .unwrap();
         assert!(!response["q"].as_array().unwrap().is_empty());
     }
 
@@ -159,9 +205,12 @@ mod tests {
 
         let (db, app, _r) = create_app().await;
 
-        let response: surf::Response = app.get("/micropub?q=config")
+        let response: surf::Response = app
+            .get("/micropub?q=config")
             .header("Authorization", "test")
-            .send().await.unwrap();
+            .send()
+            .await
+            .unwrap();
         assert_eq!(response.status(), 401);
     }
 
@@ -184,17 +233,27 @@ mod tests {
 
         let (storage, app, _r) = create_app().await;
 
-        let request: surf::RequestBuilder = app.post("/micropub")
+        let request: surf::RequestBuilder = app
+            .post("/micropub")
             .header("Authorization", "Bearer test")
             .header("Content-Type", "application/x-www-form-urlencoded")
             .body("h=entry&content=something%20interesting&category[]=test&category[]=stuff");
         let mut response: surf::Response = request.send().await.unwrap();
-        println!("{:#}", response.body_json::<serde_json::Value>().await.unwrap());
+        println!(
+            "{:#}",
+            response.body_json::<serde_json::Value>().await.unwrap()
+        );
         assert!(response.status() == 201 || response.status() == 202);
         let uid = response.header("Location").unwrap().last().to_string();
         // Assume the post is in the database at this point.
         let post = storage.get_post(&uid).await.unwrap().unwrap();
-        assert_eq!(post["properties"]["content"][0]["html"].as_str().unwrap().trim(), "<p>something interesting</p>");
+        assert_eq!(
+            post["properties"]["content"][0]["html"]
+                .as_str()
+                .unwrap()
+                .trim(),
+            "<p>something interesting</p>"
+        );
     }
 
     #[async_std::test]
@@ -207,35 +266,63 @@ mod tests {
 
         let (storage, app, _r) = create_app().await;
 
-        let mut response = post_json(&app, json!({
-            "type": ["h-entry"],
-            "properties": {
-                "content": ["This is content!"]
-            }
-        })).await;
-        println!("{:#}", response.body_json::<serde_json::Value>().await.unwrap());
+        let mut response = post_json(
+            &app,
+            json!({
+                "type": ["h-entry"],
+                "properties": {
+                    "content": ["This is content!"]
+                }
+            }),
+        )
+        .await;
+        println!(
+            "{:#}",
+            response.body_json::<serde_json::Value>().await.unwrap()
+        );
         assert!(response.status() == 201 || response.status() == 202);
         let uid = response.header("Location").unwrap().last().to_string();
         // Assume the post is in the database at this point.
         let post = storage.get_post(&uid).await.unwrap().unwrap();
-        assert_eq!(post["properties"]["content"][0]["html"].as_str().unwrap().trim(), "<p>This is content!</p>");
-        let feed = storage.get_post("https://fireburn.ru/feeds/main").await.unwrap().unwrap();
+        assert_eq!(
+            post["properties"]["content"][0]["html"]
+                .as_str()
+                .unwrap()
+                .trim(),
+            "<p>This is content!</p>"
+        );
+        let feed = storage
+            .get_post("https://fireburn.ru/feeds/main")
+            .await
+            .unwrap()
+            .unwrap();
         assert_eq!(feed["children"].as_array().unwrap().len(), 1);
         assert_eq!(feed["children"][0].as_str().unwrap(), uid);
         let first_uid = uid;
         // Test creation of a second post
-        let mut response = post_json(&app, json!({
-            "type": ["h-entry"],
-            "properties": {
-                "content": ["#moar content for you!"]
-            }
-        })).await;
-        println!("{:#}", response.body_json::<serde_json::Value>().await.unwrap());
+        let mut response = post_json(
+            &app,
+            json!({
+                "type": ["h-entry"],
+                "properties": {
+                    "content": ["#moar content for you!"]
+                }
+            }),
+        )
+        .await;
+        println!(
+            "{:#}",
+            response.body_json::<serde_json::Value>().await.unwrap()
+        );
         assert!(response.status() == 201 || response.status() == 202);
         let uid = response.header("Location").unwrap().last().to_string();
         // Assume the post is in the database at this point.
         //println!("Keys in database: {:?}", storage.mapping.read().await.keys());
-        let new_feed = storage.get_post("https://fireburn.ru/feeds/main").await.unwrap().unwrap();
+        let new_feed = storage
+            .get_post("https://fireburn.ru/feeds/main")
+            .await
+            .unwrap()
+            .unwrap();
         println!("{}", new_feed["children"]);
         assert_eq!(new_feed["children"].as_array().unwrap().len(), 2);
         assert_eq!(new_feed["children"][0].as_str().unwrap(), uid);
diff --git a/src/main.rs b/src/main.rs
index ce654df..1b333a2 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,7 +1,7 @@
+use kittybox_micropub as micropub;
+use log::{debug, error, info};
 use std::env;
-use log::{error,info,debug};
 use surf::Url;
-use kittybox_micropub as micropub;
 
 #[async_std::main]
 async fn main() -> Result<(), std::io::Error> {
@@ -16,7 +16,7 @@ async fn main() -> Result<(), std::io::Error> {
         Ok(val) => {
             debug!("Redis connection: {}", val);
             redis_uri = val
-        },
+        }
         Err(_) => {
             error!("REDIS_URI is not set, cannot find a database");
             std::process::exit(1);
@@ -50,7 +50,7 @@ async fn main() -> Result<(), std::io::Error> {
                     std::process::exit(1)
                 }
             }
-        },
+        }
         Err(_) => {
             error!("AUTHORIZATION_ENDPOINT is not set, will not be able to confirm token and ID requests using IndieAuth!");
             std::process::exit(1)
@@ -59,7 +59,15 @@ async fn main() -> Result<(), std::io::Error> {
 
     let media_endpoint: Option<String> = env::var("MEDIA_ENDPOINT").ok();
 
-    let host = env::var("SERVE_AT").ok().unwrap_or_else(|| "0.0.0.0:8080".to_string());
-    let app = micropub::get_app_with_redis(token_endpoint, authorization_endpoint, redis_uri, media_endpoint).await;
+    let host = env::var("SERVE_AT")
+        .ok()
+        .unwrap_or_else(|| "0.0.0.0:8080".to_string());
+    let app = micropub::get_app_with_redis(
+        token_endpoint,
+        authorization_endpoint,
+        redis_uri,
+        media_endpoint,
+    )
+    .await;
     app.listen(host).await
 }
diff --git a/src/micropub/get.rs b/src/micropub/get.rs
index e106883..525bf12 100644
--- a/src/micropub/get.rs
+++ b/src/micropub/get.rs
@@ -1,23 +1,26 @@
-use tide::prelude::{Deserialize, json};
-use tide::{Request, Response, Result};
-use crate::ApplicationState;
-use crate::database::{MicropubChannel,Storage};
+use crate::database::{MicropubChannel, Storage};
 use crate::indieauth::User;
+use crate::ApplicationState;
+use tide::prelude::{json, Deserialize};
+use tide::{Request, Response, Result};
 
 #[derive(Deserialize)]
 struct QueryOptions {
     q: String,
-    url: Option<String>
+    url: Option<String>,
 }
 
 pub async fn get_handler<Backend>(req: Request<ApplicationState<Backend>>) -> Result
 where
-    Backend: Storage + Send + Sync
+    Backend: Storage + Send + Sync,
 {
     let user = req.ext::<User>().unwrap();
     let backend = &req.state().storage;
     let media_endpoint = &req.state().media_endpoint;
-    let query = req.query::<QueryOptions>().unwrap_or(QueryOptions { q: "".to_string(), url: None });
+    let query = req.query::<QueryOptions>().unwrap_or(QueryOptions {
+        q: "".to_string(),
+        url: None,
+    });
     match &*query.q {
         "config" => {
             let channels: Vec<MicropubChannel>;
diff --git a/src/micropub/mod.rs b/src/micropub/mod.rs
index 9bc553c..68a3134 100644
--- a/src/micropub/mod.rs
+++ b/src/micropub/mod.rs
@@ -2,5 +2,5 @@ pub mod get;
 pub mod post;
 
 pub use get::get_handler;
+pub use post::normalize_mf2;
 pub use post::post_handler;
-pub use post::normalize_mf2;
\ No newline at end of file
diff --git a/src/micropub/post.rs b/src/micropub/post.rs
index 6183906..b3fe4ee 100644
--- a/src/micropub/post.rs
+++ b/src/micropub/post.rs
@@ -1,17 +1,17 @@
+use crate::database::Storage;
+use crate::indieauth::User;
+use crate::ApplicationState;
+use chrono::prelude::*;
 use core::iter::Iterator;
-use std::str::FromStr;
-use std::convert::TryInto;
-use log::{warn, error};
 use futures::stream;
 use futures::StreamExt;
-use chrono::prelude::*;
 use http_types::Mime;
+use log::{error, warn};
+use newbase60::num_to_sxg;
+use std::convert::TryInto;
+use std::str::FromStr;
 use tide::prelude::json;
 use tide::{Request, Response, Result};
-use newbase60::num_to_sxg;
-use crate::ApplicationState;
-use crate::database::{Storage};
-use crate::indieauth::User;
 
 static DEFAULT_CHANNEL_PATH: &str = "/feeds/main";
 static DEFAULT_CHANNEL_NAME: &str = "Main feed";
@@ -43,8 +43,9 @@ fn get_folder_from_type(post_type: &str) -> String {
         "h-card" => "vcards/",
         "h-event" => "events/",
         "h-food" => "food/",
-        _ => "posts/"
-    }).to_string()
+        _ => "posts/",
+    })
+    .to_string()
 }
 
 pub fn normalize_mf2(mut body: serde_json::Value, user: &User) -> (String, serde_json::Value) {
@@ -63,34 +64,32 @@ pub fn normalize_mf2(mut body: serde_json::Value, user: &User) -> (String, serde
                 // Do not attempt to recover the information.
                 // Do not pass GO. Do not collect $200.
                 let curtime: DateTime<Local> = Local::now();
-                body["properties"]["published"] = serde_json::Value::Array(vec![
-                    serde_json::Value::String(curtime.to_rfc3339())
-                ]);
+                body["properties"]["published"] =
+                    serde_json::Value::Array(vec![serde_json::Value::String(curtime.to_rfc3339())]);
                 published = chrono::DateTime::from(curtime);
             }
         }
     } else {
         // Set the datetime.
         let curtime: DateTime<Local> = Local::now();
-        body["properties"]["published"] = serde_json::Value::Array(vec![
-            serde_json::Value::String(curtime.to_rfc3339())
-        ]);
+        body["properties"]["published"] =
+            serde_json::Value::Array(vec![serde_json::Value::String(curtime.to_rfc3339())]);
         published = chrono::DateTime::from(curtime);
     }
     match body["properties"]["uid"][0].as_str() {
         None => {
             let uid = serde_json::Value::String(
                 me.join(
-                    &(folder.clone() + &num_to_sxg(published.timestamp_millis().try_into().unwrap()))
-                ).unwrap().to_string());
+                    &(folder.clone()
+                        + &num_to_sxg(published.timestamp_millis().try_into().unwrap())),
+                )
+                .unwrap()
+                .to_string(),
+            );
             body["properties"]["uid"] = serde_json::Value::Array(vec![uid.clone()]);
             match body["properties"]["url"].as_array_mut() {
-                Some(array) => {
-                    array.push(uid)
-                }
-                None => {
-                    body["properties"]["url"] = body["properties"]["uid"].clone()
-                }
+                Some(array) => array.push(uid),
+                None => body["properties"]["url"] = body["properties"]["uid"].clone(),
             }
         }
         Some(uid_str) => {
@@ -101,14 +100,13 @@ pub fn normalize_mf2(mut body: serde_json::Value, user: &User) -> (String, serde
                         array.push(serde_json::Value::String(uid))
                     }
                 }
-                None => {
-                    body["properties"]["url"] = body["properties"]["uid"].clone()
-                }
+                None => body["properties"]["url"] = body["properties"]["uid"].clone(),
             }
         }
     }
     if let Some(slugs) = body["properties"]["mp-slug"].as_array() {
-        let new_urls = slugs.iter()
+        let new_urls = slugs
+            .iter()
             .map(|i| i.as_str().unwrap_or(""))
             .filter(|i| i != &"")
             .map(|i| me.join(&((&folder).clone() + i)).unwrap().to_string())
@@ -147,15 +145,25 @@ pub fn normalize_mf2(mut body: serde_json::Value, user: &User) -> (String, serde
     }
     // TODO: maybe highlight #hashtags?
     // Find other processing to do and insert it here
-    return (body["properties"]["uid"][0].as_str().unwrap().to_string(), body)
+    return (
+        body["properties"]["uid"][0].as_str().unwrap().to_string(),
+        body,
+    );
 }
 
-pub async fn new_post<S: Storage>(req: Request<ApplicationState<S>>, body: serde_json::Value) -> Result {
+pub async fn new_post<S: Storage>(
+    req: Request<ApplicationState<S>>,
+    body: serde_json::Value,
+) -> Result {
     // First, check for rights.
     let user = req.ext::<User>().unwrap();
     let storage = &req.state().storage;
     if !user.check_scope("create") {
-        return error_json!(401, "invalid_scope", "Not enough privileges to post. Try a token with a \"create\" scope instead.")
+        return error_json!(
+            401,
+            "invalid_scope",
+            "Not enough privileges to post. Try a token with a \"create\" scope instead."
+        );
     }
     let (uid, post) = normalize_mf2(body, user);
 
@@ -163,29 +171,54 @@ pub async fn new_post<S: Storage>(req: Request<ApplicationState<S>>, body: serde
     // This software might also be used in a multi-user setting
     // where several users or identities share one Micropub server
     // (maybe a family website or a shitpost sideblog?)
-    if post["properties"]["url"].as_array().unwrap().iter().any(|url| !url.as_str().unwrap().starts_with(user.me.as_str()))
-        || !post["properties"]["uid"][0].as_str().unwrap().starts_with(user.me.as_str())
-        || post["properties"]["channel"].as_array().unwrap().iter().any(|url| !url.as_str().unwrap().starts_with(user.me.as_str()))
+    if post["properties"]["url"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|url| !url.as_str().unwrap().starts_with(user.me.as_str()))
+        || !post["properties"]["uid"][0]
+            .as_str()
+            .unwrap()
+            .starts_with(user.me.as_str())
+        || post["properties"]["channel"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|url| !url.as_str().unwrap().starts_with(user.me.as_str()))
     {
-        return error_json!(403, "forbidden", "You're trying to post to someone else's website...")
+        return error_json!(
+            403,
+            "forbidden",
+            "You're trying to post to someone else's website..."
+        );
     }
 
-
     match storage.post_exists(&uid).await {
-        Ok(exists) => if exists {
-            return error_json!(409, "already_exists", format!("A post with the exact same UID already exists in the database: {}", uid))
-        },
-        Err(err) => return Ok(err.into())
+        Ok(exists) => {
+            if exists {
+                return error_json!(
+                    409,
+                    "already_exists",
+                    format!(
+                        "A post with the exact same UID already exists in the database: {}",
+                        uid
+                    )
+                );
+            }
+        }
+        Err(err) => return Ok(err.into()),
     }
 
     if let Err(err) = storage.put_post(&post).await {
-        return error_json!(500, "database_error", format!("{}", err))
+        return error_json!(500, "database_error", format!("{}", err));
     }
 
     // It makes sense to use a loop here, because you wouldn't post to a hundred channels at once
     // Mostly one or two, and even those ones will be the ones picked for you by software
     for channel in post["properties"]["channel"]
-        .as_array().unwrap().iter()
+        .as_array()
+        .unwrap()
+        .iter()
         .map(|i| i.as_str().unwrap_or("").to_string())
         .filter(|i| !i.is_empty())
         .collect::<Vec<_>>()
@@ -193,22 +226,44 @@ pub async fn new_post<S: Storage>(req: Request<ApplicationState<S>>, body: serde
         let default_channel = user.me.join(DEFAULT_CHANNEL_PATH).unwrap().to_string();
         let vcards_channel = user.me.join(CONTACTS_CHANNEL_PATH).unwrap().to_string();
         match storage.post_exists(&channel).await {
-            Ok(exists) => if exists {
-                if let Err(err) = storage.update_post(&channel, json!({
-                    "add": {
-                        "children": [uid]
+            Ok(exists) => {
+                if exists {
+                    if let Err(err) = storage
+                        .update_post(
+                            &channel,
+                            json!({
+                                "add": {
+                                    "children": [uid]
+                                }
+                            }),
+                        )
+                        .await
+                    {
+                        return error_json!(
+                            500,
+                            "database_error",
+                            format!(
+                                "Couldn't insert post into the channel due to a database error: {}",
+                                err
+                            )
+                        );
                     }
-                })).await {
-                    return error_json!(500, "database_error", format!("Couldn't insert post into the channel due to a database error: {}", err))
-                }
-            } else if channel == default_channel || channel == vcards_channel {
-                if let Err(err) = create_feed(storage, &uid, &channel, &user).await {
-                    return error_json!(500, "database_error", format!("Couldn't save feed: {}", err))
+                } else if channel == default_channel || channel == vcards_channel {
+                    if let Err(err) = create_feed(storage, &uid, &channel, &user).await {
+                        return error_json!(
+                            500,
+                            "database_error",
+                            format!("Couldn't save feed: {}", err)
+                        );
+                    }
+                } else {
+                    warn!(
+                        "Ignoring request to post to a non-existent feed: {}",
+                        channel
+                    );
                 }
-            } else {
-                warn!("Ignoring request to post to a non-existent feed: {}", channel);
-            },
-            Err(err) => return error_json!(500, "database_error", err)
+            }
+            Err(err) => return error_json!(500, "database_error", err),
         }
     }
     // END WRITE BOUNDARY
@@ -222,26 +277,39 @@ pub async fn new_post<S: Storage>(req: Request<ApplicationState<S>>, body: serde
         .build());
 }
 
-async fn create_feed(storage: &impl Storage, uid: &str, channel: &str, user: &User) -> crate::database::Result<()> {
+async fn create_feed(
+    storage: &impl Storage,
+    uid: &str,
+    channel: &str,
+    user: &User,
+) -> crate::database::Result<()> {
     let path = url::Url::parse(channel).unwrap().path().to_string();
     let (name, slug) = if path == DEFAULT_CHANNEL_PATH {
         (DEFAULT_CHANNEL_NAME, "main")
     } else if path == CONTACTS_CHANNEL_PATH {
         (CONTACTS_CHANNEL_NAME, "vcards")
-    } else { panic!("Tried to create an unknown default feed!"); };
-
-    let (_, feed) = normalize_mf2(json!({
-        "type": ["h-feed"],
-        "properties": {
-            "name": [name],
-            "mp-slug": [slug],
-        },
-        "children": [uid]
-    }), &user);
+    } else {
+        panic!("Tried to create an unknown default feed!");
+    };
+
+    let (_, feed) = normalize_mf2(
+        json!({
+            "type": ["h-feed"],
+            "properties": {
+                "name": [name],
+                "mp-slug": [slug],
+            },
+            "children": [uid]
+        }),
+        &user,
+    );
     storage.put_post(&feed).await
 }
 
-async fn post_process_new_post<S: Storage>(req: Request<ApplicationState<S>>, post: serde_json::Value) {
+async fn post_process_new_post<S: Storage>(
+    req: Request<ApplicationState<S>>,
+    post: serde_json::Value,
+) {
     // TODO: Post-processing the post (aka second write pass)
     // - [-] Download rich reply contexts
     // - [-] Syndicate the post if requested, add links to the syndicated copies
@@ -262,11 +330,9 @@ async fn post_process_new_post<S: Storage>(req: Request<ApplicationState<S>>, po
     for prop in &["in-reply-to", "like-of", "repost-of", "bookmark-of"] {
         if let Some(array) = post["properties"][prop].as_array() {
             contextually_significant_posts.extend(
-                array.iter()
-                    .filter_map(|v| v.as_str()
-                        .and_then(|v| surf::Url::parse(v).ok()
-                    )
-                )
+                array
+                    .iter()
+                    .filter_map(|v| v.as_str().and_then(|v| surf::Url::parse(v).ok())),
             );
         }
     }
@@ -275,26 +341,28 @@ async fn post_process_new_post<S: Storage>(req: Request<ApplicationState<S>>, po
     contextually_significant_posts.dedup();
 
     // 1.3. Fetch the posts with their bodies and save them in a new Vec<(surf::Url, String)>
-    let posts_with_bodies: Vec<(surf::Url, String)> = stream::iter(contextually_significant_posts.into_iter())
-        .filter_map(|v: surf::Url| async move {
-            if let Ok(res) = http.get(&v).send().await {
-                if res.status() != 200 {
-                    return None
+    let posts_with_bodies: Vec<(surf::Url, String)> =
+        stream::iter(contextually_significant_posts.into_iter())
+            .filter_map(|v: surf::Url| async move {
+                if let Ok(res) = http.get(&v).send().await {
+                    if res.status() != 200 {
+                        return None;
+                    } else {
+                        return Some((v, res));
+                    }
                 } else {
-                    return Some((v, res))
+                    return None;
                 }
-            } else {
-                return None
-            }
-        })
-        .filter_map(|(v, mut res): (surf::Url, surf::Response)| async move {
-            if let Ok(body) = res.body_string().await {
-                return Some((v, body))
-            } else {
-                return None
-            }
-        })
-        .collect().await;
+            })
+            .filter_map(|(v, mut res): (surf::Url, surf::Response)| async move {
+                if let Ok(body) = res.body_string().await {
+                    return Some((v, body));
+                } else {
+                    return None;
+                }
+            })
+            .collect()
+            .await;
     // 1.4. Parse the bodies and include them in relevant places on the MF2 struct
     //      This requires an MF2 parser, and there are none for Rust at the moment.
     //
@@ -303,24 +371,32 @@ async fn post_process_new_post<S: Storage>(req: Request<ApplicationState<S>>, po
     // 2. Syndicate the post
     let syndicated_copies: Vec<serde_json::Value>;
     if let Some(syndication_targets) = post["properties"]["syndicate-to"].as_array() {
-        syndicated_copies = stream::iter(syndication_targets.into_iter()
-            .filter_map(|v| v.as_str())
-            .filter_map(|t| surf::Url::parse(t).ok())
-            .collect::<Vec<_>>().into_iter()
-            .map(|_t: surf::Url| async move {
-                // TODO: Define supported syndication methods
-                // and syndicate the endpoint there
-                // Possible ideas:
-                //  - indieweb.xyz (might need a lot of space for the buttons though, investigate proposing grouping syndication targets)
-                //  - news.indieweb.org (IndieNews - needs a category linking to #indienews)
-                //  - Twitter via brid.gy (do I really need Twitter syndication tho?)
-                if false {
-                    Some("")
-                } else {
-                    None
-                }
-            })
-        ).buffer_unordered(3).filter_map(|v| async move { v }).map(|v| serde_json::Value::String(v.to_string())).collect::<Vec<_>>().await;
+        syndicated_copies = stream::iter(
+            syndication_targets
+                .into_iter()
+                .filter_map(|v| v.as_str())
+                .filter_map(|t| surf::Url::parse(t).ok())
+                .collect::<Vec<_>>()
+                .into_iter()
+                .map(|_t: surf::Url| async move {
+                    // TODO: Define supported syndication methods
+                    // and syndicate the endpoint there
+                    // Possible ideas:
+                    //  - indieweb.xyz (might need a lot of space for the buttons though, investigate proposing grouping syndication targets)
+                    //  - news.indieweb.org (IndieNews - needs a category linking to #indienews)
+                    //  - Twitter via brid.gy (do I really need Twitter syndication tho?)
+                    if false {
+                        Some("")
+                    } else {
+                        None
+                    }
+                }),
+        )
+        .buffer_unordered(3)
+        .filter_map(|v| async move { v })
+        .map(|v| serde_json::Value::String(v.to_string()))
+        .collect::<Vec<_>>()
+        .await;
     } else {
         syndicated_copies = vec![]
     }
@@ -363,35 +439,67 @@ async fn post_process_new_post<S: Storage>(req: Request<ApplicationState<S>>, po
             // TODO: Replace this function once the MF2 parser is ready
             // A compliant parser's output format includes rels,
             // we could just find a Webmention one in there
-            let pattern = easy_scraper::Pattern::new(r#"<link href="{url}" rel="webmention">"#).expect("Pattern for webmentions couldn't be parsed");
+            let pattern = easy_scraper::Pattern::new(r#"<link href="{url}" rel="webmention">"#)
+                .expect("Pattern for webmentions couldn't be parsed");
             let matches = pattern.matches(&body);
-            if matches.is_empty() { return None }
+            if matches.is_empty() {
+                return None;
+            }
             let endpoint = &matches[0]["url"];
-            if let Ok(endpoint) = url.join(endpoint) { Some((url, endpoint)) } else { None }
+            if let Ok(endpoint) = url.join(endpoint) {
+                Some((url, endpoint))
+            } else {
+                None
+            }
         })
         .map(|(target, endpoint)| async move {
-            let response = http.post(&endpoint)
+            let response = http
+                .post(&endpoint)
                 .content_type("application/x-www-form-urlencoded")
                 .body(
-                    serde_urlencoded::to_string(vec![("source", source), ("target", &target.to_string())])
-                        .expect("Couldn't construct webmention form")
-                ).send().await;
+                    serde_urlencoded::to_string(vec![
+                        ("source", source),
+                        ("target", &target.to_string()),
+                    ])
+                    .expect("Couldn't construct webmention form"),
+                )
+                .send()
+                .await;
             match response {
-                Ok(response) => if response.status() == 200 || response.status() == 201 || response.status() == 202 {
-                    Ok(())
-                } else {
-                    error!("Sending webmention for {} to {} failed: Endpoint replied with HTTP {}", target, endpoint, response.status());
-                    Err(())
+                Ok(response) => {
+                    if response.status() == 200
+                        || response.status() == 201
+                        || response.status() == 202
+                    {
+                        Ok(())
+                    } else {
+                        error!(
+                            "Sending webmention for {} to {} failed: Endpoint replied with HTTP {}",
+                            target,
+                            endpoint,
+                            response.status()
+                        );
+                        Err(())
+                    }
                 }
                 Err(err) => {
-                    error!("Sending webmention for {} to {} failed: {}", target, endpoint, err);
+                    error!(
+                        "Sending webmention for {} to {} failed: {}",
+                        target, endpoint, err
+                    );
                     Err(())
                 }
             }
-        }).buffer_unordered(3).collect::<Vec<_>>().await;
+        })
+        .buffer_unordered(3)
+        .collect::<Vec<_>>()
+        .await;
 }
 
-async fn process_json<S: Storage>(req: Request<ApplicationState<S>>, body: serde_json::Value) -> Result {
+async fn process_json<S: Storage>(
+    req: Request<ApplicationState<S>>,
+    body: serde_json::Value,
+) -> Result {
     let is_action = body["action"].is_string() && body["url"].is_string();
     if is_action {
         // This could be an update, a deletion or an undeletion request.
@@ -402,37 +510,51 @@ async fn process_json<S: Storage>(req: Request<ApplicationState<S>>, body: serde
         match action {
             "delete" => {
                 if !user.check_scope("delete") {
-                    return error_json!(401, "insufficient_scope", "You need a `delete` scope to delete posts.")
+                    return error_json!(
+                        401,
+                        "insufficient_scope",
+                        "You need a `delete` scope to delete posts."
+                    );
                 }
                 if let Err(error) = req.state().storage.delete_post(&url).await {
-                    return Ok(error.into())
+                    return Ok(error.into());
                 }
                 return Ok(Response::builder(200).build());
-            },
+            }
             "update" => {
                 if !user.check_scope("update") {
-                    return error_json!(401, "insufficient_scope", "You need an `update` scope to update posts.")
+                    return error_json!(
+                        401,
+                        "insufficient_scope",
+                        "You need an `update` scope to update posts."
+                    );
                 }
                 if let Err(error) = req.state().storage.update_post(&url, body.clone()).await {
-                    return Ok(error.into())
+                    return Ok(error.into());
                 } else {
-                    return Ok(Response::builder(204).build())
+                    return Ok(Response::builder(204).build());
                 }
-            },
-            _ => {
-                return error_json!(400, "invalid_request", "This action is not supported.")
             }
+            _ => return error_json!(400, "invalid_request", "This action is not supported."),
         }
     } else if body["type"][0].is_string() {
         // This is definitely an h-entry or something similar. Check if it has properties?
         if body["properties"].is_object() {
             // Ok, this is definitely a new h-entry. Let's save it.
-            return new_post(req, body).await
+            return new_post(req, body).await;
         } else {
-            return error_json!(400, "invalid_request", "This MF2-JSON object has a type, but not properties. This makes no sense to post.")
+            return error_json!(
+                400,
+                "invalid_request",
+                "This MF2-JSON object has a type, but not properties. This makes no sense to post."
+            );
         }
     } else {
-        return error_json!(400, "invalid_request", "Try sending MF2-structured data or an object with an \"action\" and \"url\" keys.")
+        return error_json!(
+            400,
+            "invalid_request",
+            "Try sending MF2-structured data or an object with an \"action\" and \"url\" keys."
+        );
     }
 }
 
@@ -440,12 +562,15 @@ fn convert_form_to_mf2_json(form: Vec<(String, String)>) -> serde_json::Value {
     let mut mf2 = json!({"type": [], "properties": {}});
     for (k, v) in form {
         if k == "h" {
-            mf2["type"].as_array_mut().unwrap().push(json!("h-".to_string() + &v));
+            mf2["type"]
+                .as_array_mut()
+                .unwrap()
+                .push(json!("h-".to_string() + &v));
         } else if k != "access_token" {
             let key = k.strip_suffix("[]").unwrap_or(&k);
             match mf2["properties"][key].as_array_mut() {
                 Some(prop) => prop.push(json!(v)),
-                None => mf2["properties"][key] = json!([v])
+                None => mf2["properties"][key] = json!([v]),
             }
         }
     }
@@ -455,33 +580,50 @@ fn convert_form_to_mf2_json(form: Vec<(String, String)>) -> serde_json::Value {
     mf2
 }
 
-async fn process_form<S: Storage>(req: Request<ApplicationState<S>>, form: Vec<(String, String)>) -> Result {
+async fn process_form<S: Storage>(
+    req: Request<ApplicationState<S>>,
+    form: Vec<(String, String)>,
+) -> Result {
     if let Some((_, v)) = form.iter().find(|(k, _)| k == "action") {
         if v == "delete" {
             let user = req.ext::<User>().unwrap();
             if !user.check_scope("delete") {
-                return error_json!(401, "insufficient_scope", "You cannot delete posts without a `delete` scope.")
+                return error_json!(
+                    401,
+                    "insufficient_scope",
+                    "You cannot delete posts without a `delete` scope."
+                );
             }
             match form.iter().find(|(k, _)| k == "url") {
                 Some((_, url)) => {
                     if let Err(error) = req.state().storage.delete_post(&url).await {
-                        return error_json!(500, "database_error", error)
+                        return error_json!(500, "database_error", error);
                     }
-                    return Ok(Response::builder(200).build())
-                },
-                None => return error_json!(400, "invalid_request", "Please provide an `url` to delete.")
+                    return Ok(Response::builder(200).build());
+                }
+                None => {
+                    return error_json!(
+                        400,
+                        "invalid_request",
+                        "Please provide an `url` to delete."
+                    )
+                }
             }
         } else {
-            return error_json!(400, "invalid_request", "This action is not supported in form-encoded mode. (JSON requests support more actions, use JSON!)")
+            return error_json!(400, "invalid_request", "This action is not supported in form-encoded mode. (JSON requests support more actions, use JSON!)");
         }
     }
-    
+
     let mf2 = convert_form_to_mf2_json(form);
 
     if mf2["properties"].as_object().unwrap().keys().len() > 0 {
         return new_post(req, mf2).await;
     }
-    return error_json!(400, "invalid_request", "Try sending h=entry&content=something%20interesting");
+    return error_json!(
+        400,
+        "invalid_request",
+        "Try sending h=entry&content=something%20interesting"
+    );
 }
 
 pub async fn post_handler<S: Storage>(mut req: Request<ApplicationState<S>>) -> Result {
@@ -489,29 +631,31 @@ pub async fn post_handler<S: Storage>(mut req: Request<ApplicationState<S>>) ->
         Some(value) => {
             if value == Mime::from_str("application/json").unwrap() {
                 match req.body_json::<serde_json::Value>().await {
-                    Ok(parsed) => {
-                        return process_json(req, parsed).await
-                    },
-                    Err(err) => return error_json!(
-                        400, "invalid_request",
-                        format!("Parsing JSON failed: {:?}", err)
-                    )
+                    Ok(parsed) => return process_json(req, parsed).await,
+                    Err(err) => {
+                        return error_json!(
+                            400,
+                            "invalid_request",
+                            format!("Parsing JSON failed: {:?}", err)
+                        )
+                    }
                 }
             } else if value == Mime::from_str("application/x-www-form-urlencoded").unwrap() {
                 match req.body_form::<Vec<(String, String)>>().await {
-                    Ok(parsed) => {
-                        return process_form(req, parsed).await
-                    },
-                    Err(err) => return error_json!(
-                        400, "invalid_request",
-                        format!("Parsing form failed: {:?}", err)
-                    )
+                    Ok(parsed) => return process_form(req, parsed).await,
+                    Err(err) => {
+                        return error_json!(
+                            400,
+                            "invalid_request",
+                            format!("Parsing form failed: {:?}", err)
+                        )
+                    }
                 }
             } else {
                 return error_json!(
                     415, "unsupported_media_type",
                     "What's this? Try sending JSON instead. (urlencoded form also works but is less cute)"
-                )
+                );
             }
         }
         _ => {
@@ -538,9 +682,22 @@ mod tests {
             }
         });
 
-        let (uid, normalized) = normalize_mf2(mf2.clone(), &User::new("https://fireburn.ru/", "https://quill.p3k.io/", "create update media"));
-        assert_eq!(normalized["properties"]["uid"][0], mf2["properties"]["uid"][0], "UID was replaced");
-        assert_eq!(normalized["properties"]["uid"][0], uid, "Returned post location doesn't match UID");
+        let (uid, normalized) = normalize_mf2(
+            mf2.clone(),
+            &User::new(
+                "https://fireburn.ru/",
+                "https://quill.p3k.io/",
+                "create update media",
+            ),
+        );
+        assert_eq!(
+            normalized["properties"]["uid"][0], mf2["properties"]["uid"][0],
+            "UID was replaced"
+        );
+        assert_eq!(
+            normalized["properties"]["uid"][0], uid,
+            "Returned post location doesn't match UID"
+        );
     }
 
     #[test]
@@ -548,7 +705,7 @@ mod tests {
         use serde_urlencoded::from_str;
 
         assert_eq!(
-            convert_form_to_mf2_json(from_str("h=entry&content=something%20interesting").unwrap()), 
+            convert_form_to_mf2_json(from_str("h=entry&content=something%20interesting").unwrap()),
             json!({
                 "type": ["h-entry"],
                 "properties": {
@@ -567,16 +724,64 @@ mod tests {
             }
         });
 
-        let (uid, post) = normalize_mf2(mf2, &User::new("https://fireburn.ru/", "https://quill.p3k.io/", "create update media"));
-        assert_eq!(post["properties"]["published"].as_array().expect("post['published'] is undefined").len(), 1, "Post doesn't have a published time");
-        DateTime::parse_from_rfc3339(post["properties"]["published"][0].as_str().unwrap()).expect("Couldn't parse date from rfc3339");
-        assert!(post["properties"]["url"].as_array().expect("post['url'] is undefined").len() > 0, "Post doesn't have any URLs");
-        assert_eq!(post["properties"]["uid"].as_array().expect("post['uid'] is undefined").len(), 1, "Post doesn't have a single UID");
-        assert_eq!(post["properties"]["uid"][0], uid, "UID of a post and its supposed location don't match");
-        assert!(uid.starts_with("https://fireburn.ru/posts/"), "The post namespace is incorrect");
-        assert_eq!(post["properties"]["content"][0]["html"].as_str().expect("Post doesn't have a rich content object").trim(), "<p>This is content!</p>", "Parsed Markdown content doesn't match expected HTML");
-        assert_eq!(post["properties"]["channel"][0], "https://fireburn.ru/feeds/main", "Post isn't posted to the main channel");
-        assert_eq!(post["properties"]["author"][0], "https://fireburn.ru/", "Post author is unknown");
+        let (uid, post) = normalize_mf2(
+            mf2,
+            &User::new(
+                "https://fireburn.ru/",
+                "https://quill.p3k.io/",
+                "create update media",
+            ),
+        );
+        assert_eq!(
+            post["properties"]["published"]
+                .as_array()
+                .expect("post['published'] is undefined")
+                .len(),
+            1,
+            "Post doesn't have a published time"
+        );
+        DateTime::parse_from_rfc3339(post["properties"]["published"][0].as_str().unwrap())
+            .expect("Couldn't parse date from rfc3339");
+        assert!(
+            post["properties"]["url"]
+                .as_array()
+                .expect("post['url'] is undefined")
+                .len()
+                > 0,
+            "Post doesn't have any URLs"
+        );
+        assert_eq!(
+            post["properties"]["uid"]
+                .as_array()
+                .expect("post['uid'] is undefined")
+                .len(),
+            1,
+            "Post doesn't have a single UID"
+        );
+        assert_eq!(
+            post["properties"]["uid"][0], uid,
+            "UID of a post and its supposed location don't match"
+        );
+        assert!(
+            uid.starts_with("https://fireburn.ru/posts/"),
+            "The post namespace is incorrect"
+        );
+        assert_eq!(
+            post["properties"]["content"][0]["html"]
+                .as_str()
+                .expect("Post doesn't have a rich content object")
+                .trim(),
+            "<p>This is content!</p>",
+            "Parsed Markdown content doesn't match expected HTML"
+        );
+        assert_eq!(
+            post["properties"]["channel"][0], "https://fireburn.ru/feeds/main",
+            "Post isn't posted to the main channel"
+        );
+        assert_eq!(
+            post["properties"]["author"][0], "https://fireburn.ru/",
+            "Post author is unknown"
+        );
     }
 
     #[test]
@@ -589,15 +794,27 @@ mod tests {
             },
         });
 
-        let (_, post) = normalize_mf2(mf2, &User::new("https://fireburn.ru/", "https://quill.p3k.io/", "create update media"));
-        assert!(post["properties"]["url"]
-            .as_array()
-            .unwrap()
-            .iter()
-            .map(|i| i.as_str().unwrap())
-            .any(|i| i == "https://fireburn.ru/posts/hello-post"),
-            "Didn't found an URL pointing to the location expected by the mp-slug semantics");
-        assert!(post["properties"]["mp-slug"].as_array().is_none(), "mp-slug wasn't deleted from the array!")
+        let (_, post) = normalize_mf2(
+            mf2,
+            &User::new(
+                "https://fireburn.ru/",
+                "https://quill.p3k.io/",
+                "create update media",
+            ),
+        );
+        assert!(
+            post["properties"]["url"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .map(|i| i.as_str().unwrap())
+                .any(|i| i == "https://fireburn.ru/posts/hello-post"),
+            "Didn't found an URL pointing to the location expected by the mp-slug semantics"
+        );
+        assert!(
+            post["properties"]["mp-slug"].as_array().is_none(),
+            "mp-slug wasn't deleted from the array!"
+        )
     }
 
     #[test]
@@ -610,16 +827,31 @@ mod tests {
             }
         });
 
-        let (uid, post) = normalize_mf2(mf2, &User::new("https://fireburn.ru/", "https://quill.p3k.io/", "create update media"));
-        assert_eq!(post["properties"]["uid"][0], uid, "UID of a post and its supposed location don't match");
+        let (uid, post) = normalize_mf2(
+            mf2,
+            &User::new(
+                "https://fireburn.ru/",
+                "https://quill.p3k.io/",
+                "create update media",
+            ),
+        );
+        assert_eq!(
+            post["properties"]["uid"][0], uid,
+            "UID of a post and its supposed location don't match"
+        );
         assert_eq!(post["properties"]["author"][0], "https://fireburn.ru/");
-        assert!(post["properties"]["url"]
-            .as_array()
-            .unwrap()
-            .iter()
-            .map(|i| i.as_str().unwrap())
-            .any(|i| i == "https://fireburn.ru/feeds/main"),
-        "Didn't found an URL pointing to the location expected by the mp-slug semantics");
-        assert!(post["properties"]["mp-slug"].as_array().is_none(), "mp-slug wasn't deleted from the array!")
+        assert!(
+            post["properties"]["url"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .map(|i| i.as_str().unwrap())
+                .any(|i| i == "https://fireburn.ru/feeds/main"),
+            "Didn't found an URL pointing to the location expected by the mp-slug semantics"
+        );
+        assert!(
+            post["properties"]["mp-slug"].as_array().is_none(),
+            "mp-slug wasn't deleted from the array!"
+        )
     }
-}
\ No newline at end of file
+}