SDS: run cargo fmt && clippy

Signed-off-by: Harshit Jain <reach@harsh1998.dev>

Author: dev-harsh1998

.github/workflows/rust.yml

@@ -30,11 +30,18 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
       - run: cargo clippy -- -D warnings
 
-  coverage:
-    name: Code coverage
-    runs-on: ubuntu-latest
+  macos:
+    name: MacOS
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - run: cargo test --all-features -vv
+
+  windows:
+    name: Windows
+    runs-on: windows-latest
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
-      - run: cargo install cargo-tarpaulin
-      - run: cargo tarpaulin --ignore-tests
+      - run: cargo test --all-features -vv

src/cli.rs

@@ -51,4 +51,4 @@ pub struct Cli {
     /// Password for basic authentication.
     #[arg(long)]
     pub password: Option<String>,
-}
+}

src/error.rs

@@ -17,16 +17,16 @@ pub enum AppError {
 impl fmt::Display for AppError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            AppError::Io(err) => write!(f, "IO error: {}", err),
-            AppError::Glob(err) => write!(f, "Glob pattern error: {}", err),
-            AppError::AddrParse(err) => write!(f, "Address parse error: {}", err),
+            AppError::Io(err) => write!(f, "IO error: {err}"),
+            AppError::Glob(err) => write!(f, "Glob pattern error: {err}"),
+            AppError::AddrParse(err) => write!(f, "Address parse error: {err}"),
             AppError::InvalidPath => write!(f, "Invalid path"),
-            AppError::DirectoryNotFound(path) => write!(f, "Directory not found: {}", path),
+            AppError::DirectoryNotFound(path) => write!(f, "Directory not found: {path}"),
             AppError::Forbidden => write!(f, "Forbidden"),
             AppError::NotFound => write!(f, "Not Found"),
             AppError::BadRequest => write!(f, "Bad Request"),
             AppError::Unauthorized => write!(f, "Unauthorized"),
-            AppError::InternalServerError(msg) => write!(f, "Internal server error: {}", msg),
+            AppError::InternalServerError(msg) => write!(f, "Internal server error: {msg}"),
         }
     }
 }

src/fs.rs

@@ -10,22 +10,26 @@ use std::time::SystemTime;
 
 /// Checks if the given path is a directory.
 pub fn is_directory(file_directory: &Arc<Mutex<PathBuf>>) -> Result<bool, AppError> {
-    let dir_guard = file_directory.lock().map_err(|_| {
-        AppError::InternalServerError("Failed to lock directory mutex".to_string())
-    })?;
+    let dir_guard = file_directory
+        .lock()
+        .map_err(|_| AppError::InternalServerError("Failed to lock directory mutex".to_string()))?;
     Ok(Path::new(&*dir_guard).is_dir())
 }
 
 /// Generates an HTML directory listing for a given path.
 pub fn generate_directory_listing(path: &Path, log_prefix: &str) -> Result<String, AppError> {
-    debug!("{} Generating directory listing for: '{}'", log_prefix, path.display());
+    debug!(
+        "{} Generating directory listing for: '{}'",
+        log_prefix,
+        path.display()
+    );
 
     let mut entries: Vec<PathBuf> = Vec::new();
     for entry_result in fs::read_dir(path)? {
         match entry_result {
             Ok(entry) => entries.push(entry.path()),
             Err(e) => {
-                warn!("{} Skipping directory entry due to error: {}", log_prefix, e);
+                warn!("{log_prefix} Skipping directory entry due to error: {e}");
             }
         }
     }
@@ -124,16 +128,19 @@ pub fn generate_directory_listing(path: &Path, log_prefix: &str) -> Result<Strin
                          </tr>
                      </thead>
                      <tbody>
-                         {}
+                         {table_rows_html}
                      </tbody>
                  </table>
              </div>
          </body>
          </html>
-         "#,
-        table_rows_html
+         "#
+    );
+    debug!(
+        "{} Directory listing HTML generated for: '{}'",
+        log_prefix,
+        path.display()
     );
-    debug!("{} Directory listing HTML generated for: '{}'", log_prefix, path.display());
     Ok(html)
 }
 
@@ -150,7 +157,6 @@ pub fn generate_directory_row_html(path: &Path, _log_prefix: &str) -> Result<Str
     let relative_path = percent_encode_path(Path::new(&filename.to_string()));
 
     Ok(format!(
-        "<tr><td><a href=\"{}\">{}</a></td><td>{}</td><td>{}</td></tr>",
-        relative_path, filename, file_size_human, last_modified_str
+        "<tr><td><a href=\"{relative_path}\">{filename}</a></td><td>{file_size_human}</td><td>{last_modified_str}</td></tr>"
     ))
 }

src/http.rs

@@ -1,9 +1,9 @@
-use base64::engine::general_purpose;
-use base64::Engine;
 use crate::error::AppError;
 use crate::fs::generate_directory_listing;
 use crate::response::send_response;
 use crate::utils::get_request_path;
+use base64::engine::general_purpose;
+use base64::Engine;
 use glob::Pattern;
 use log::{debug, error, info, warn};
 use std::collections::HashMap;
@@ -14,6 +14,7 @@ use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
+#[allow(clippy::too_many_arguments)]
 pub fn handle_client(
     mut stream: TcpStream,
     file_directory: &Arc<Mutex<PathBuf>>,
@@ -41,6 +42,7 @@ pub fn handle_client(
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn handle_request(
     stream: &mut TcpStream,
     file_directory: &Arc<Mutex<PathBuf>>,
@@ -64,7 +66,7 @@ fn handle_request(
         }
     };
 
-    debug!("{} Request line: {}", log_prefix, request_line);
+    debug!("{log_prefix} Request line: {request_line}");
 
     let mut headers_map = HashMap::new();
     for line in lines_iter {
@@ -77,14 +79,20 @@ fn handle_request(
         }
     }
 
-    if let (Some(username), Some(password)) = (username.as_ref().as_ref(), password.as_ref().as_ref()) {
+    if let (Some(username), Some(password)) =
+        (username.as_ref().as_ref(), password.as_ref().as_ref())
+    {
         if !authenticate(&headers_map, username, password)? {
             return Err(AppError::Unauthorized);
         }
     }
 
     let request_path_str = get_request_path(&request_line);
-    let request_path = PathBuf::from(request_path_str.strip_prefix('/').unwrap_or(request_path_str));
+    let request_path = PathBuf::from(
+        request_path_str
+            .strip_prefix('/')
+            .unwrap_or(request_path_str),
+    );
 
     let full_path = file_directory.lock().unwrap().join(&request_path);
     let canonical_path = match full_path.canonicalize() {
@@ -108,13 +116,7 @@ fn handle_request(
         .iter()
         .any(|pattern| pattern.matches_path(&request_path))
     {
-        serve_file(
-            stream,
-            &canonical_path,
-            headers_map,
-            chunk_size,
-            log_prefix,
-        )?;
+        serve_file(stream, &canonical_path, headers_map, chunk_size, log_prefix)?;
     } else {
         warn!(
             "{} File extension not allowed for path: '{}'",
@@ -130,33 +132,42 @@ fn handle_request(
 fn send_error_response(stream: &mut TcpStream, err: AppError, log_prefix: &str) {
     let (status_code, status_text, body) = match err {
         AppError::NotFound => (404, "Not Found", "The requested resource was not found."),
-        AppError::Forbidden => (403, "Forbidden", "You do not have permission to access this resource."),
-        AppError::BadRequest => (400, "Bad Request", "The server could not understand the request."),
+        AppError::Forbidden => (
+            403,
+            "Forbidden",
+            "You do not have permission to access this resource.",
+        ),
+        AppError::BadRequest => (
+            400,
+            "Bad Request",
+            "The server could not understand the request.",
+        ),
         AppError::Unauthorized => (401, "Unauthorized", "Authentication required."),
         AppError::InternalServerError(ref msg) => (500, "Internal Server Error", msg.as_str()),
         AppError::Io(ref e)
             if e.kind() == ErrorKind::ConnectionReset
                 || e.kind() == ErrorKind::BrokenPipe
                 || e.kind() == ErrorKind::WouldBlock =>
         {
-            warn!(
-                "{} Connection error when sending response: {}",
-                log_prefix, e
-            );
+            warn!("{log_prefix} Connection error when sending response: {e}");
             return;
         }
-        _ => (500, "Internal Server Error", "An unexpected error occurred."),
+        _ => (
+            500,
+            "Internal Server Error",
+            "An unexpected error occurred.",
+        ),
     };
 
-    error!("{} Responding with error {}: {}", log_prefix, status_code, status_text);
+    error!("{log_prefix} Responding with error {status_code}: {status_text}");
 
     let mut headers = HashMap::new();
     if status_code == 401 {
         headers.insert("WWW-Authenticate", "Basic realm=\"Restricted\"");
     }
 
     if let Err(e) = send_response(stream, status_code, status_text, body, log_prefix) {
-        error!("{} Failed to send error response: {}", log_prefix, e);
+        error!("{log_prefix} Failed to send error response: {e}");
     }
 }
 
@@ -195,7 +206,11 @@ fn serve_file(
     chunk_size: usize,
     log_prefix: &str,
 ) -> Result<(), AppError> {
-    info!("{} serve_file started for: '{}'", log_prefix, path.display());
+    info!(
+        "{} serve_file started for: '{}'",
+        log_prefix,
+        path.display()
+    );
     let mut file = match File::open(path) {
         Ok(f) => f,
         Err(e) if e.kind() == ErrorKind::NotFound => return Err(AppError::NotFound),
@@ -220,13 +235,11 @@ fn serve_file(
 
     let content_length = end_byte - start_byte + 1;
     let mut response = format!(
-        "HTTP/1.1 {} {}\r\nContent-Disposition: attachment; filename=\"{}\"\r\nContent-Length: {}\r\nContent-Type: application/octet-stream\r\nAccept-Ranges: bytes\r\n",
-        status_code, status_text, filename, content_length
+        "HTTP/1.1 {status_code} {status_text}\r\nContent-Disposition: attachment; filename=\"{filename}\"\r\nContent-Length: {content_length}\r\nContent-Type: application/octet-stream\r\nAccept-Ranges: bytes\r\n"
     );
     if status_code == 206 {
         response.push_str(&format!(
-            "Content-Range: bytes {}-{}/{}\r\n",
-            start_byte, end_byte, file_size
+            "Content-Range: bytes {start_byte}-{end_byte}/{file_size}\r\n"
         ));
     }
     response.push_str("\r\n");
@@ -246,20 +259,28 @@ fn serve_file(
         bytes_remaining -= bytes_read as u64;
     }
 
-    info!("{} serve_file finished for: '{}'", log_prefix, path.display());
+    info!(
+        "{} serve_file finished for: '{}'",
+        log_prefix,
+        path.display()
+    );
     Ok(())
 }
 
 /// Serves a directory listing as an HTML page.
-fn serve_directory(
-    stream: &mut TcpStream,
-    path: &Path,
-    log_prefix: &str,
-) -> Result<(), AppError> {
-    info!("{} serve_directory started for: '{}'", log_prefix, path.display());
+fn serve_directory(stream: &mut TcpStream, path: &Path, log_prefix: &str) -> Result<(), AppError> {
+    info!(
+        "{} serve_directory started for: '{}'",
+        log_prefix,
+        path.display()
+    );
     let html = generate_directory_listing(path, log_prefix)?;
     send_response(stream, 200, "OK", &html, log_prefix)?;
-    info!("{} serve_directory finished for: '{}'", log_prefix, path.display());
+    info!(
+        "{} serve_directory finished for: '{}'",
+        log_prefix,
+        path.display()
+    );
     Ok(())
 }
 

src/lib.rs

@@ -5,16 +5,16 @@
 /// This library contains the core logic for the server. The `run` function
 /// initializes and starts the server based on command-line arguments.
 pub mod cli;
-pub mod response;
-pub mod server;
 pub mod error;
-pub mod http;
 pub mod fs;
+pub mod http;
+pub mod response;
+pub mod server;
 pub mod utils;
 
-use log::{error};
 use crate::cli::Cli;
 use clap::Parser;
+use log::error;
 
 /// Initializes the logger, parses command-line arguments, and starts the server.
 ///
@@ -37,12 +37,10 @@ pub fn run() {
     }
     env_logger::init();
 
-    log::debug!("Log level set to: {}", log_level);
+    log::debug!("Log level set to: {log_level}");
 
     if let Err(e) = server::run_server(cli, None, None) {
-        error!("Server error: {}", e);
+        error!("Server error: {e}");
         std::process::exit(1);
     }
 }
-
-

src/main.rs

@@ -2,4 +2,4 @@ use hdl_sv::run;
 
 fn main() {
     run();
-}
+}