feat(request): introduce structured request builder and improve UI

Add dedicated Request structure for client configuration and templating:
- Create Request struct to scaffold HTTP client configuration
- Move client builder from CLI to Request module for better separation
- Improve status code visualization with consistent ordering
- Update statistics labels for clarity
- Reposition URL in request layout for better readability

Author: omarmhaimdat

install.sh

@@ -49,7 +49,7 @@ elif [ "$(uname -s)" = "Linux" ]; then
     echo "ID: $ID"
     [ -n "$ID_LIKE" ] && echo "ID_LIKE: $ID_LIKE"
 
-   TEMP_DIR=/var/folders/dd/6w95nrsn6jn2qd5w439kzdzr0000gn/T/tmp.VwMa2wkGff
+   TEMP_DIR=/var/folders/dd/6w95nrsn6jn2qd5w439kzdzr0000gn/T/tmp.Bjv8tI4Qmq
     cd ""
 
     echo "Downloading binary..."

src/cli.rs

@@ -1,10 +1,10 @@
 use clap::{ArgAction::HelpLong, Error, Parser};
 use curl_parser;
-use reqwest::{header::USER_AGENT, Proxy};
+use reqwest::Proxy;
 use serde::Deserialize;
 
+use crate::request::{Request, RequestSettings};
 use crate::utils::{default_user_agent, num_of_cores, version};
-use crate::PepeError;
 
 const BBLUE: &str = "\x1b[1;34m"; // Bold Blue
 const BGREEN: &str = "\x1b[1;32m"; // Bold Green
@@ -193,59 +193,25 @@ impl Cli {
         Ok(())
     }
 
-    pub fn build_client(&self) -> Result<reqwest::Client, PepeError> {
-        let mut request_headers = reqwest::header::HeaderMap::new();
-
-        // Add user agent
-        request_headers.insert(
-            USER_AGENT,
-            self.user_agent
-                .parse::<reqwest::header::HeaderValue>()
-                .map_err(|e| PepeError::HeaderParseError(e.to_string()))?,
-        );
-
-        // Parse headers safely
-        for header in &self.headers {
-            let parts: Vec<&str> = header.splitn(2, ':').collect();
-            if parts.len() == 2 {
-                let name = reqwest::header::HeaderName::from_bytes(parts[0].trim().as_bytes())
-                    .map_err(|e| PepeError::HeaderParseError(e.to_string()))?;
-                let value = reqwest::header::HeaderValue::from_str(parts[1].trim())
-                    .map_err(|e| PepeError::HeaderParseError(e.to_string()))?;
-                request_headers.insert(name, value);
-            }
-        }
-
-        let mut client_builder = reqwest::Client::builder()
-            .default_headers(request_headers)
-            .timeout(std::time::Duration::from_secs(self.timeout as u64));
-
-        if let Some(proxy_url) = &self.proxy {
-            let proxy =
-                Proxy::all(proxy_url).map_err(|e| PepeError::HeaderParseError(e.to_string()))?;
-            client_builder = client_builder.proxy(proxy);
+    pub fn settings(&self) -> RequestSettings {
+        RequestSettings {
+            user_agent: self.user_agent.clone(),
+            timeout: self.timeout,
+            proxy: self.proxy.clone(),
+            disable_compression: self.disable_compression,
+            disable_keepalive: self.disable_keepalive,
+            disable_redirects: self.disable_redirects,
         }
+    }
 
-        if self.disable_compression {
-            client_builder = client_builder.no_gzip();
-        }
-
-        if self.disable_keepalive {
-            client_builder = client_builder.connection_verbose(true);
-        }
-
-        if self.disable_redirects {
-            client_builder = client_builder.redirect(reqwest::redirect::Policy::none());
-        }
-
-        client_builder =
-            client_builder.timeout(std::time::Duration::from_secs(self.timeout as u64));
-
-        let client: reqwest::Client = client_builder
-            .build()
-            .map_err(|e| PepeError::RequestError(e))?;
-
-        Ok(client)
+    pub fn request(&self) -> Request {
+        Request::new(
+            self.url.clone(),
+            self.method.clone(),
+            self.body.clone(),
+            self.headers.clone(),
+            self.settings(),
+        )
     }
 
     pub async fn check_for_updates(&self) -> Result<(), Box<dyn std::error::Error>> {

src/main.rs

@@ -10,12 +10,14 @@ use crossterm::{
 };
 use tokio::sync::{mpsc, Semaphore};
 
+use crate::cli::Cli;
+use crate::request::Request;
 use crate::response::ResponseStats;
 use crate::utils::resolve_dns;
-use cli::Cli;
 
 mod cache;
 mod cli;
+mod request;
 mod response;
 mod ui;
 mod utils;
@@ -50,28 +52,26 @@ impl std::error::Error for PepeError {}
 
 async fn handle_request(
     client: Arc<reqwest::Client>,
-    url: String,
-    method: String,
-    body: Option<String>,
+    request: Request,
     tx: mpsc::Sender<ResponseStats>,
     sent_tx: mpsc::Sender<Sent>,
     permit: tokio::sync::OwnedSemaphorePermit,
 ) {
     let start = std::time::Instant::now();
-    let method = reqwest::Method::from_bytes(method.as_bytes()).unwrap_or(reqwest::Method::GET);
+    let method = request.method();
 
     let _ = sent_tx.send(Sent { count: 1 }).await;
 
-    let dns_times = resolve_dns(&url).await.unwrap_or_default();
+    let dns_times = resolve_dns(&request.url).await.unwrap_or_default();
 
-    let response = if method == reqwest::Method::POST && body.is_some() {
+    let response = if method == reqwest::Method::POST && request.body.is_some() {
         client
-            .request(method, &url)
-            .body(body.unwrap())
+            .request(method, &request.url)
+            .body(request.body.unwrap())
             .send()
             .await
     } else {
-        client.request(method, &url).send().await
+        client.request(method, &request.url).send().await
     };
 
     let stats = ResponseStats::from_response(response, start, dns_times).await;
@@ -85,17 +85,15 @@ async fn run_request(
     tx: mpsc::Sender<ResponseStats>,
     sent_tx: mpsc::Sender<Sent>,
 ) -> Result<(Vec<ResponseStats>, std::time::Duration), PepeError> {
-    let client = Arc::new(args.build_client()?);
+    let request = args.request();
+    let client = Arc::new(request.build_client()?);
     let all_start = std::time::Instant::now();
     let semaphore = Arc::new(Semaphore::new(args.concurrency as usize));
 
     let handler = tokio::spawn({
         let client = client.clone();
         let tx = tx;
         let sent_tx = sent_tx;
-        let url = args.url.clone();
-        let method = args.method.clone();
-        let body = args.body.clone();
         let number = args.number;
 
         async move {
@@ -108,9 +106,7 @@ async fn run_request(
 
                 tokio::spawn(handle_request(
                     client.clone(),
-                    url.clone(),
-                    method.clone(),
-                    body.clone(),
+                    request.clone(),
                     tx.clone(),
                     sent_tx.clone(),
                     permit,

src/request.rs

@@ -0,0 +1,109 @@
+use std::collections::HashMap;
+
+use reqwest::{header::USER_AGENT, Proxy};
+
+use crate::PepeError;
+
+#[derive(Debug, Clone)]
+pub struct RequestSettings {
+    pub timeout: u32,
+    pub disable_compression: bool,
+    pub disable_keepalive: bool,
+    pub disable_redirects: bool,
+    pub proxy: Option<String>,
+    pub user_agent: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct Request {
+    pub url: String,
+    pub method: String,
+    pub body: Option<String>,
+    pub headers: HashMap<String, String>,
+    pub settings: RequestSettings,
+}
+
+impl Request {
+    pub fn new(
+        url: String,
+        method: String,
+        body: Option<String>,
+        headers: Vec<String>,
+        settings: RequestSettings,
+    ) -> Self {
+        let mut header_map = HashMap::new();
+        for header in headers {
+            let parts: Vec<&str> = header.splitn(2, ':').collect();
+            if parts.len() == 2 {
+                header_map.insert(parts[0].trim().to_string(), parts[1].trim().to_string());
+            }
+        }
+
+        Self {
+            url,
+            method,
+            body,
+            headers: header_map,
+            settings,
+        }
+    }
+
+    pub fn method(&self) -> reqwest::Method {
+        reqwest::Method::from_bytes(self.method.as_bytes()).unwrap_or(reqwest::Method::GET)
+    }
+
+    fn parse_headers(headers: &HashMap<String, String>) -> reqwest::header::HeaderMap {
+        let mut request_headers = reqwest::header::HeaderMap::new();
+        for (name, value) in headers {
+            request_headers.insert(
+                reqwest::header::HeaderName::from_bytes(name.as_bytes()).unwrap(),
+                reqwest::header::HeaderValue::from_str(value).unwrap(),
+            );
+        }
+        request_headers
+    }
+
+    pub fn build_client(&self) -> Result<reqwest::Client, PepeError> {
+        let mut request_headers = Self::parse_headers(&self.headers);
+
+        // Add user agent
+        request_headers.insert(
+            USER_AGENT,
+            self.settings
+                .user_agent
+                .parse::<reqwest::header::HeaderValue>()
+                .map_err(|e| PepeError::HeaderParseError(e.to_string()))?,
+        );
+
+        let mut client_builder = reqwest::Client::builder()
+            .default_headers(request_headers)
+            .timeout(std::time::Duration::from_secs(self.settings.timeout as u64));
+
+        if let Some(proxy_url) = &self.settings.proxy {
+            let proxy =
+                Proxy::all(proxy_url).map_err(|e| PepeError::HeaderParseError(e.to_string()))?;
+            client_builder = client_builder.proxy(proxy);
+        }
+
+        if self.settings.disable_compression {
+            client_builder = client_builder.no_gzip();
+        }
+
+        if self.settings.disable_keepalive {
+            client_builder = client_builder.connection_verbose(true);
+        }
+
+        if self.settings.disable_redirects {
+            client_builder = client_builder.redirect(reqwest::redirect::Policy::none());
+        }
+
+        client_builder =
+            client_builder.timeout(std::time::Duration::from_secs(self.settings.timeout as u64));
+
+        let client: reqwest::Client = client_builder
+            .build()
+            .map_err(|e| PepeError::RequestError(e))?;
+
+        Ok(client)
+    }
+}