Update docs, README.md and cargo, Add doctests

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "krustie"
-version = "0.1.7"
+version = "0.1.8"
 description = "Krustie is a backend framework written in Rust. Currently, it is a work in progress and not yet ready for production use."
 categories = ["network-programming", "web-programming::http-server"]
 keywords = ["http", "web", "framework"]

README.md

@@ -9,55 +9,26 @@ Krustie is a backend framework written in Rust. It is currently a work in progre
 
 ## Features
 
-- Basic request and response handling
 - Stackable Router
-- General Middleware support
-- Router Middleware support
+- Middleware support
 - JSON parsing ([serde_json](https://crates.io/crates/serde_json))
 
 ### Builtin Middlewares
 
 - Static file serving
 - Gzip encoding ([flate2](https://crates.io/crates/flate2))
 
-## Getting Started
-
-### Prerequisites
-
-Before you begin, ensure you have the following installed:
-
-- [Rust](https://www.rust-lang.org/)
-- [Cargo](https://doc.rust-lang.org/cargo/)
-
-### Installation
-
-#### Add Krustie to your project
-
-Include it in your `Cargo.toml`:
-
-```toml
-[dependencies]
-krustie = "0.1.6"
-```
-
-Run the following Cargo command in your project directory:
-
-```bash
-cargo add krustie
-```
-
-#### Start your server
+## Start your server
 
 ```rust
-use krustie::{ Server, Router, StatusCodes };
+use krustie::{ response::ContentType, Router, Server, StatusCode };
 
 fn main() {
     let mut server = Server::create();
     let mut router = Router::new();
 
     router.get(|_, res| {
-        res.status(StatusCode::Ok)
-            .body(b"Hello World!".to_vec(), "text/plain");
+        res.status(StatusCode::Ok).body(b"Hello World!".to_vec(), ContentType::Text);
     });
 
     server.use_handler(router);
@@ -66,12 +37,6 @@ fn main() {
 }
 ```
 
-#### Run your server
-
-```bash
-cargo run
-```
-
 ## Contributing
 
 As an inexperienced developer contributions will be welcomed. Please open an issue or a pull request.

src/json.rs

@@ -6,6 +6,31 @@ pub use serde_json::Result as JsonResult;
 pub use serde_json::to_string as struct_to_string;
 
 /// Converts a `JsonValue` (`serde_json::Value`) to a string
+///
+/// # Example
+///
+/// ```rust
+/// fn post_req(req: &Request, res: &mut Response) {
+///   match req.get_body() {
+///     RequestBody::Json(body) => {
+///       let server_key_option = body.get("server");
+///
+///       match get_string_from_json(server_key_option).unwrap() {
+///         "Krustie" => {
+///           res.status(StatusCode::Ok).body_json(body.clone());
+///         },
+///         _ => {
+///           res.status(StatusCode::try_from(201).unwrap()).body_json(
+///             json!({"error": "Invalid server"})
+///           );
+///         }
+///       }
+///     },
+///     _ => {
+///         res.status(StatusCode::BadRequest).body_json(json!({"error": "Invalid JSON"}));
+///     }
+///   }
+/// }
 pub fn get_string_from_json(json_key: Option<&JsonValue>) -> Option<String> {
     json_key.map(|value| trim_json_string(value.to_string()))
 }

src/request.rs

@@ -56,6 +56,7 @@ impl Request {
     /// fn get(request: &Request, response: &mut Response) {
     ///   let content_type = request.get_header("content-type");
     /// }
+    /// ```
     pub fn get_header(&self, key: &str) -> Option<&String> {
         self.headers.get(key)
     }
@@ -82,25 +83,58 @@ impl Request {
     ///     }
     ///   }
     /// }
-    ///
+    /// ```
     pub fn get_body(&self) -> &RequestBody {
         &self.body
     }
 
     /// Adds a local variable to the http request
     ///
     /// `Local` variables can be used to store data that can be defined in a *middleware* and accessed in the *controller*
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use krustie::{ Request, Response };
+    ///
+    /// fn get(request: &Request, response: &mut Response) {
+    ///   request.add_local("user_id", "123");
+    /// }
+    /// ```
     pub fn add_local(&mut self, key: &str, value: &str) {
         self.locals.insert(key.to_string(), value.to_string());
     }
 
     /// Returns the value of the local variable
     ///
     /// `Local` variables can be used to store data that can be defined in a *middleware* and accessed in the *controller*
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use krustie::{ Request, Response };
+    ///
+    /// fn get(request: &Request, response: &mut Response) {
+    ///    let user_id = request.get_local("user_id");
+    /// }
+    /// ```
     pub fn get_local(&self, key: &str) -> Option<&String> {
         self.locals.get(key)
     }
 
+    /// Returns the peer address of the HTTP request
+    ///
+    /// The peer address is the address of the client that made the request
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use krustie::{ Request, Response };
+    ///
+    /// fn get(request: &Request, response: &mut Response) {
+    ///   let peer_addr: &SocketAddr = request.get_peer_addr();
+    /// }
+    /// ```
     pub fn get_peer_addr(&self) -> &SocketAddr {
         &self.peer_addr
     }

src/response/body.rs

@@ -42,6 +42,7 @@ impl Response {
     /// fn get(request: &Request, response: &mut Response) {
     ///    response.body_json(json!({"message": "Hello, World!"}));
     /// }
+    /// ```
     pub fn body_json(&mut self, data: JsonValue) -> &mut Self {
         let json = serde_json::to_string(&data).unwrap();
         self.body(json.as_bytes().to_vec(), ContentType::Json);

src/response/content_type.rs

@@ -26,7 +26,7 @@ pub enum ContentType {
     /// Represents the `application/zip` content type
     Zip,
     // Image
-    /// Represents the `image/png` content type 
+    /// Represents the `image/png` content type
     Png,
     /// Represents the `image/jpeg` content type
     Jpeg,

src/response/utilities.rs

@@ -1,5 +1,5 @@
 //! Response utilities
-//! 
+//!
 //! This module contains utility functions for the response object.
 
 use std::collections::HashMap;
@@ -37,6 +37,7 @@ impl Response {
     ///     println!("{}: {}", key, value);
     ///   }
     /// }
+    /// ```
     pub fn get_headers(&self) -> &HashMap<String, String> {
         &self.headers
     }
@@ -56,6 +57,7 @@ impl Response {
     ///     None => println!("Server header not found")
     ///   }
     /// }
+    /// ```
     pub fn get_header(&self, key: &str) -> Option<&String> {
         self.headers.get(key)
     }
@@ -70,6 +72,7 @@ impl Response {
     /// fn get(request: &Request, response: &mut Response) {
     ///   let body = response.get_body();
     /// }
+    /// ```
     pub fn get_body(&mut self) -> &Vec<u8> {
         &mut self.body
     }
@@ -84,6 +87,7 @@ impl Response {
     /// fn get(request: &Request, response: &mut Response) {
     ///   let body = response.get_body();
     /// }
+    /// ```
     pub fn get_body_mut(&mut self) -> &mut Vec<u8> {
         &mut self.body
     }
@@ -106,6 +110,7 @@ impl Response {
     ///
     ///   response.update_body(b"Goodbye, Mars!".to_vec());
     /// }
+    /// ```
     pub fn update_body(&mut self, body: Vec<u8>) -> Result<(), String> {
         if self.body.len() == 0 {
             return Err("Request has no body.".to_string());