refactor code for improved clarity, consistency, and maintainability.

umit · umit · commit af5931a1eb49 · 2025-05-31T20:10:38.000+03:00
diff --git a/Makefile b/Makefile
@@ -53,10 +53,26 @@ doc:
 .PHONY: lint
 lint:
 	@echo "Running linter..."
-	@cargo clippy -- -D warnings
+	@cargo clippy --all-targets -- \
+		-D warnings \
+		-D dead_code \
+		-D unused_imports \
+		-D unused_variables \
+		-D unused_assignments \
+		-D missing_docs \
+		-D unsafe_code \
+		-D clippy::all
 
 # Run the linter and fix issues where possible
 .PHONY: lint-fix
 lint-fix:
 	@echo "Running linter and fixing issues..."
-	@cargo clippy --fix -- -D warnings
+	@cargo clippy --fix --allow-dirty --all-targets -- \
+		-D warnings \
+		-D dead_code \
+		-D unused_imports \
+		-D unused_variables \
+		-D unused_assignments \
+		-D missing_docs \
+		-D unsafe_code \
+		-D clippy::all
diff --git a/examples/http_server.rs b/examples/http_server.rs
@@ -5,7 +5,6 @@ use microhttp_rs::{
 };
 use serde::{Deserialize, Serialize};
 use log::{info};
-use env_logger;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -37,7 +36,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
         Ok(HttpResponse::new(StatusCode::Ok)
             .with_content_type("text/plain")
-            .with_body_string(format!("Hello, {}!", name)))
+            .with_body_string(format!("Hello, {name}!")))
     }).await;
 
     // Define data structures for JSON
@@ -64,7 +63,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
                 HttpResponse::new(StatusCode::Ok)
                     .with_json(&data)
-                    .map_err(|e| ServerError::InternalError(format!("JSON error: {}", e)))
+                    .map_err(|e| ServerError::InternalError(format!("JSON error: {e}")))
             },
             Method::POST => {
                 // Process the request and return a response
@@ -74,7 +73,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
                 HttpResponse::new(StatusCode::Created)
                     .with_json(&data)
-                    .map_err(|e| ServerError::InternalError(format!("JSON error: {}", e)))
+                    .map_err(|e| ServerError::InternalError(format!("JSON error: {e}")))
             },
             _ => Err(ServerError::InternalError("Unexpected method".to_string())),
         }
@@ -99,12 +98,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
                 HttpResponse::new(StatusCode::Created)
                     .with_json(&response)
-                    .map_err(|e| ServerError::InternalError(format!("JSON error: {}", e)))
+                    .map_err(|e| ServerError::InternalError(format!("JSON error: {e}")))
             },
             Err(e) => {
                 Ok(HttpResponse::new(StatusCode::BadRequest)
                     .with_content_type("text/plain")
-                    .with_body_string(format!("Invalid JSON: {}", e)))
+                    .with_body_string(format!("Invalid JSON: {e}")))
             }
         }
     }).await;
@@ -131,7 +130,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         let mut response_body = String::from("Request Headers:\n\n");
 
         for (name, value) in &req.headers {
-            response_body.push_str(&format!("{}: {}\n", name, value));
+            response_body.push_str(&format!("{name}: {value}\n"));
         }
 
         Ok(HttpResponse::new(StatusCode::Ok)
diff --git a/examples/simple_parser.rs b/examples/simple_parser.rs
@@ -2,7 +2,6 @@
 
 use microhttp_rs::parse_request;
 use log::{info, error};
-use env_logger;
 
 fn main() {
     // Initialize the logger
@@ -20,11 +19,11 @@ fn main() {
             info!("Version: {}", request.version);
             info!("Headers:");
             for (name, value) in &request.headers {
-                info!("  {}: {}", name, value);
+                info!("  {name}: {value}");
             }
         }
         Err(err) => {
-            error!("Error parsing request: {}", err);
+            error!("Error parsing request: {err}");
         }
     }
 
@@ -36,7 +35,7 @@ fn main() {
             error!("Unexpectedly parsed invalid request!");
         }
         Err(err) => {
-            info!("Expected error parsing invalid request: {}", err);
+            info!("Expected error parsing invalid request: {err}");
         }
     }
 }
diff --git a/examples/simple_server.rs b/examples/simple_server.rs
@@ -4,7 +4,6 @@ use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpListener;
 use microhttp_rs::{parse_request, ParserError};
 use log::{info, error, debug};
-use env_logger;
 
 #[tokio::main]
 async fn main() -> std::io::Result<()> {
@@ -17,7 +16,7 @@ async fn main() -> std::io::Result<()> {
     loop {
         // Accept incoming connections
         let (mut socket, addr) = listener.accept().await?;
-        info!("Connection from: {}", addr);
+        info!("Connection from: {addr}");
 
         // Spawn a new task for each connection
         tokio::spawn(async move {
@@ -26,7 +25,7 @@ async fn main() -> std::io::Result<()> {
             // Read data from the socket
             match socket.read(&mut buf).await {
                 Ok(n) if n > 0 => {
-                    debug!("Received {} bytes", n);
+                    debug!("Received {n} bytes");
 
                     // Parse the HTTP request
                     let response = match parse_request(&buf[..n]) {
@@ -50,18 +49,18 @@ async fn main() -> std::io::Result<()> {
                             )
                         },
                         Err(err) => {
-                            error!("Error parsing request: {}", err);
+                            error!("Error parsing request: {err}");
 
                             // Generate an error response
                             let error_message = match err {
                                 ParserError::InvalidPath => "Invalid HTTP path".to_string(),
-                                ParserError::MissingHeader(header) => format!("Required header is missing: {}", header),
+                                ParserError::MissingHeader(header) => format!("Required header is missing: {header}"),
                                 ParserError::InvalidHeaderFormat => "Invalid header format".to_string(),
-                                ParserError::InvalidMethod(method) => format!("Invalid HTTP method: {}", method),
-                                ParserError::InvalidVersion(version) => format!("Invalid HTTP version: {}", version),
-                                ParserError::MalformedRequestLine(line) => format!("Malformed request line: {}", line),
+                                ParserError::InvalidMethod(method) => format!("Invalid HTTP method: {method}"),
+                                ParserError::InvalidVersion(version) => format!("Invalid HTTP version: {version}"),
+                                ParserError::MalformedRequestLine(line) => format!("Malformed request line: {line}"),
                                 ParserError::EmptyRequest => "Empty request".to_string(),
-                                ParserError::JsonError(e) => format!("JSON parsing error: {}", e),
+                                ParserError::JsonError(e) => format!("JSON parsing error: {e}"),
                             };
 
                             format!(
@@ -78,14 +77,14 @@ async fn main() -> std::io::Result<()> {
 
                     // Write the response back to the client
                     if let Err(e) = socket.write_all(response.as_bytes()).await {
-                        error!("Error writing response: {}", e);
+                        error!("Error writing response: {e}");
                     }
                 },
                 Ok(_) => {
                     info!("Client closed connection");
                 },
                 Err(e) => {
-                    error!("Error reading from socket: {}", e);
+                    error!("Error reading from socket: {e}");
                 }
             }
         });
diff --git a/src/parser/method.rs b/src/parser/method.rs
@@ -8,12 +8,19 @@ use crate::parser::error::Error;
 /// HTTP request methods as defined in RFC 7231 and common extensions.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum Method {
+    /// GET method: Requests a representation of the specified resource.
     GET,
+    /// POST method: Submits data to be processed to the identified resource.
     POST,
+    /// PUT method: Replaces all current representations of the target resource with the request payload.
     PUT,
+    /// DELETE method: Deletes the specified resource.
     DELETE,
+    /// HEAD method: Same as GET but only transfers the status line and header section.
     HEAD,
+    /// OPTIONS method: Describes the communication options for the target resource.
     OPTIONS,
+    /// PATCH method: Applies partial modifications to a resource.
     PATCH,
 }
 
diff --git a/src/parser/mod.rs b/src/parser/mod.rs
@@ -7,7 +7,6 @@ mod request;
 mod method;
 mod version;
 mod error;
-mod tests;
 
 // Re-export public items
 pub use request::HttpRequest;
@@ -16,4 +15,4 @@ pub use version::HttpVersion;
 pub use error::Error;
 
 // Re-export the parse_request function
-pub use request::parse_request;
+pub use request::parse_request;
diff --git a/src/parser/version.rs b/src/parser/version.rs
@@ -8,8 +8,11 @@ use crate::parser::error::Error;
 /// Supported HTTP protocol versions.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum HttpVersion {
+    /// HTTP/1.0: The first version of the HTTP protocol widely used on the web.
     Http10,
+    /// HTTP/1.1: Improved version with persistent connections, chunked transfer encoding, and more.
     Http11,
+    /// HTTP/2.0: Major revision with multiplexing, header compression, and server push capabilities.
     Http20,
 }
 
@@ -34,4 +37,4 @@ impl fmt::Display for HttpVersion {
             HttpVersion::Http20 => write!(f, "HTTP/2"),
         }
     }
-}
+}
diff --git a/src/server/response.rs b/src/server/response.rs
@@ -8,18 +8,31 @@ use crate::server::error::Error;
 /// HTTP status codes with their standard reason phrases.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum StatusCode {
+    /// 200 OK: The request has succeeded.
     Ok = 200,
+    /// 201 Created: The request has been fulfilled and a new resource has been created.
     Created = 201,
+    /// 202 Accepted: The request has been accepted for processing, but processing has not been completed.
     Accepted = 202,
+    /// 204 No Content: The server has fulfilled the request but does not need to return a response body.
     NoContent = 204,
+    /// 400 Bad Request: The server cannot process the request due to a client error.
     BadRequest = 400,
+    /// 401 Unauthorized: Authentication is required and has failed or has not been provided.
     Unauthorized = 401,
+    /// 403 Forbidden: The server understood the request but refuses to authorize it.
     Forbidden = 403,
+    /// 404 Not Found: The requested resource could not be found.
     NotFound = 404,
+    /// 405 Method Not Allowed: The request method is not supported for the requested resource.
     MethodNotAllowed = 405,
+    /// 500 Internal Server Error: The server encountered an unexpected condition.
     InternalServerError = 500,
+    /// 501 Not Implemented: The server does not support the functionality required to fulfill the request.
     NotImplemented = 501,
+    /// 502 Bad Gateway: The server received an invalid response from an upstream server.
     BadGateway = 502,
+    /// 503 Service Unavailable: The server is currently unable to handle the request.
     ServiceUnavailable = 503,
 }
 
diff --git a/src/server/tests.rs b/src/server/tests.rs

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,6 @@`
`2`	`2`
`3`	`3`	`use microhttp_rs::parse_request;`
`4`	`4`	`use log::{info, error};`
`5`		`-use env_logger;`
`6`	`5`
`7`	`6`	`fn main() {`
`8`	`7`	`// Initialize the logger`
`@@ -20,11 +19,11 @@ fn main() {`
`20`	`19`	`info!("Version: {}", request.version);`
`21`	`20`	`info!("Headers:");`
`22`	`21`	`for (name, value) in &request.headers {`
`23`		`- info!(" {}: {}", name, value);`
	`22`	`+ info!(" {name}: {value}");`
`24`	`23`	`}`
`25`	`24`	`}`
`26`	`25`	`Err(err) => {`
`27`		`- error!("Error parsing request: {}", err);`
	`26`	`+ error!("Error parsing request: {err}");`
`28`	`27`	`}`
`29`	`28`	`}`
`30`	`29`
`@@ -36,7 +35,7 @@ fn main() {`
`36`	`35`	`error!("Unexpectedly parsed invalid request!");`
`37`	`36`	`}`
`38`	`37`	`Err(err) => {`
`39`		`- info!("Expected error parsing invalid request: {}", err);`
	`38`	`+ info!("Expected error parsing invalid request: {err}");`
`40`	`39`	`}`
`41`	`40`	`}`
`42`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,11 @@ use crate::parser::error::Error;`
`8`	`8`	`/// Supported HTTP protocol versions.`
`9`	`9`	`#[derive(Debug, Clone, Copy, PartialEq, Eq)]`
`10`	`10`	`pub enum HttpVersion {`
	`11`	`+ /// HTTP/1.0: The first version of the HTTP protocol widely used on the web.`
`11`	`12`	`Http10,`
	`13`	`+ /// HTTP/1.1: Improved version with persistent connections, chunked transfer encoding, and more.`
`12`	`14`	`Http11,`
	`15`	`+ /// HTTP/2.0: Major revision with multiplexing, header compression, and server push capabilities.`
`13`	`16`	`Http20,`
`14`	`17`	`}`
`15`	`18`
`@@ -34,4 +37,4 @@ impl fmt::Display for HttpVersion {`
`34`	`37`	`HttpVersion::Http20 => write!(f, "HTTP/2"),`
`35`	`38`	`}`
`36`	`39`	`}`
`37`		`-}`
	`40`	`+}`