Update project info and format code

Author: HitomiTenshi

.vscode/extensions.json

@@ -3,6 +3,6 @@
         "adpyke.vscode-sql-formatter",
         "editorconfig.editorconfig",
         "esbenp.prettier-vscode",
-        "matklad.rust-analyzer"
+        "rust-lang.rust-analyzer"
     ]
 }

.vscode/settings.json

@@ -6,7 +6,7 @@
         "editor.formatOnSave": false
     },
     "[rust]": {
-        "editor.defaultFormatter": "matklad.rust-analyzer"
+        "editor.defaultFormatter": "rust-lang.rust-analyzer"
     },
     "[sql]": {
         "editor.defaultFormatter": "adpyke.vscode-sql-formatter"

Cargo.lock

@@ -1,8 +1,11 @@
 [package]
 name = "dekinai"
-description = "Dekinai is a simple and minimalistic file uploading API.\nIt provides the bare minimum feature set for file hosting services, while also being fast and portable."
 version = "1.1.0"
+description = "Dekinai is a simple and minimalistic file uploading API.\nIt provides the bare minimum feature set for file hosting services, while also being fast and portable."
+categories = ["filesystem", "network-programming", "web-programming::http-server"]
+keywords = ["file", "upload", "host", "hoster", "hosting"]
 authors = ["Johann Rekowski <johann.rekowski@gmail.com>"]
+repository = "https://github.com/HitomiTenshi/dekinai.git"
 license = "MIT"
 edition = "2021"
 rust-version = "1.59"

Cargo.toml

@@ -16,14 +16,11 @@ pub fn get_matches() -> ArgMatches {
                         .parse::<usize>()
                         .map(|port| PORT_RANGE.contains(&port))
                         .map_err(|err| err.to_string())
-                        .and_then(|result| match result {
-                            true => Ok(()),
-                            false => Err(format!(
-                                "Port needs to be a number between {} and {}",
-                                PORT_RANGE.start(),
-                                PORT_RANGE.end()
-                            )),
-                        })
+                        .and_then(|result| if result { Ok(()) } else { Err(format!(
+                            "Port needs to be a number between {} and {}",
+                            PORT_RANGE.start(),
+                            PORT_RANGE.end()
+                        )) })
                 }),
         )
         .arg(arg!(-u --unix <FILE> "Sets the unix socket to listen on (Unix only)").required(false))
@@ -34,9 +31,10 @@ pub fn get_matches() -> ArgMatches {
                 .validator(validate_dir)
         )
         .arg(arg!(--password <TEXT> "Sets a password for API requests").required(false).env("DEKINAI_PASSWORD").validator(|value| {
-            match value.is_ascii() {
-                true => Ok(()),
-                false => Err("Password needs to contain only ASCII characters")
+            if value.is_ascii() {
+                Ok(())
+            } else {
+                Err("Password needs to contain only ASCII characters")
             }
         }))
         .arg(arg!(-b --blacklist <FILE_EXTENSIONS> "Sets a list of disallowed file extensions\nUsage: --blacklist asp html php").required(false).multiple_values(true))
@@ -45,8 +43,9 @@ pub fn get_matches() -> ArgMatches {
 }
 
 fn validate_dir(path: &str) -> Result<(), String> {
-    match Path::new(path).is_dir() {
-        true => Ok(()),
-        false => Err(format!("Cannot access directory \"{}\"", path)),
+    if Path::new(path).is_dir() {
+        Ok(())
+    } else {
+        Err(format!("Cannot access directory \"{}\"", path))
     }
 }

src/cli.rs

@@ -38,7 +38,7 @@ impl From<&ArgMatches> for AppConfig {
         Self {
             blacklist: matches
                 .values_of("blacklist")
-                .map(|values| values.map(|str| str.to_lowercase()).collect()),
+                .map(|values| values.map(str::to_lowercase).collect()),
             output: PathBuf::from(matches.value_of("output").unwrap()),
             password_hash: matches
                 .value_of("password")

src/config.rs

@@ -19,16 +19,16 @@ pub enum Error {
 
 #[allow(non_snake_case)]
 impl Error {
-    pub fn BadRequest<T>(_: T) -> Error {
-        Error::BAD_REQUEST
+    pub fn BadRequest<T>(_: T) -> Self {
+        Self::BAD_REQUEST
     }
 
-    pub fn InternalServerError<T>(_: T) -> Error {
-        Error::INTERNAL_SERVER_ERROR
+    pub fn InternalServerError<T>(_: T) -> Self {
+        Self::INTERNAL_SERVER_ERROR
     }
 
-    pub fn Unauthorized<T>(_: T) -> Error {
-        Error::UNAUTHORIZED
+    pub fn Unauthorized<T>(_: T) -> Self {
+        Self::UNAUTHORIZED
     }
 }
 
@@ -39,10 +39,10 @@ impl ResponseError for Error {
 
     fn status_code(&self) -> StatusCode {
         match *self {
-            Error::BAD_REQUEST => StatusCode::BAD_REQUEST,
-            Error::INTERNAL_SERVER_ERROR => StatusCode::INTERNAL_SERVER_ERROR,
-            Error::NOT_FOUND => StatusCode::NOT_FOUND,
-            Error::UNAUTHORIZED => StatusCode::UNAUTHORIZED,
+            Self::BAD_REQUEST => StatusCode::BAD_REQUEST,
+            Self::INTERNAL_SERVER_ERROR => StatusCode::INTERNAL_SERVER_ERROR,
+            Self::NOT_FOUND => StatusCode::NOT_FOUND,
+            Self::UNAUTHORIZED => StatusCode::UNAUTHORIZED,
         }
     }
 }

src/lib.rs

@@ -56,12 +56,11 @@ pub async fn upload(req: HttpRequest, mut payload: Multipart) -> Result<web::Jso
         .await?;
 
         while let Some(chunk) = &field.next().await {
-            match chunk {
-                Ok(bytes) => file.write_all(bytes).await.map_err(Error::InternalServerError)?,
-                _ => {
-                    let _ = fs::remove_file(&file_path).await;
-                    return Err(Error::INTERNAL_SERVER_ERROR);
-                }
+            if let Ok(bytes) = chunk {
+                file.write_all(bytes).await.map_err(Error::InternalServerError)?;
+            } else {
+                let _unused = fs::remove_file(&file_path).await;
+                return Err(Error::INTERNAL_SERVER_ERROR);
             }
         }
 
@@ -85,7 +84,7 @@ pub async fn delete(req: HttpRequest, path: web::Path<(String, String)>) -> Resu
         if let Some(deletion_password) = &db::get_deletion_password(pool, file_stem, &file_extension).await? {
             validate_password(deletion_password, &path.1)?;
             db::delete_file(pool, file_stem, &file_extension).await?;
-            let _ = fs::remove_file(file_path).await;
+            let _unused = fs::remove_file(file_path).await;
             Ok("File has been deleted.")
         } else {
             Err(Error::UNAUTHORIZED)
@@ -114,10 +113,10 @@ async fn create_random_file(
     let file_stem = lib::get_random_text(rng, 8);
     let deletion_password = lib::get_random_text(rng, 24);
 
-    let filename = if !file_extension.is_empty() {
-        file_stem.to_owned() + "." + file_extension
+    let filename = if file_extension.is_empty() {
+        file_stem.clone()
     } else {
-        file_stem.to_owned()
+        file_stem.clone() + "." + file_extension
     };
 
     let file_path = config.output.join(&filename);
@@ -139,9 +138,9 @@ async fn create_random_file(
                 filename,
                 deletion_password,
             ));
-        } else {
-            db::delete_file(pool, &file_stem, file_extension).await?;
         }
+
+        db::delete_file(pool, &file_stem, file_extension).await?;
     }
 
     create_random_file(config, rng, pool, file_extension).await