refactor: moved HeaderMap into MessageHead

darkseid-is · darkseid-is · commit 385012892ab7 · 2025-06-15T12:23:29.000+05:30
diff --git a/header-plz/src/body_headers/encoding_info.rs b/header-plz/src/body_headers/encoding_info.rs
@@ -3,7 +3,7 @@ use crate::body_headers::content_encoding::ContentEncoding;
 #[cfg_attr(any(test, debug_assertions), derive(Debug, PartialEq, Eq, Clone))]
 pub struct EncodingInfo {
     header_index: usize,
-    pub encoding: ContentEncoding,
+    encoding: ContentEncoding,
 }
 
 impl From<(usize, ContentEncoding)> for EncodingInfo {
@@ -23,6 +23,10 @@ impl EncodingInfo {
         }
     }
 
+    pub fn encoding(&self) -> &ContentEncoding {
+        &self.encoding
+    }
+
     pub fn iter_from_str(index: usize, val: &str) -> impl Iterator<Item = EncodingInfo> {
         val.split(',')
             .map(str::trim)
diff --git a/header-plz/src/body_headers/from_header_map.rs b/header-plz/src/body_headers/from_header_map.rs
@@ -1,38 +1,7 @@
 use mime_plz::ContentType;
 
 use super::{BodyHeader, transfer_types::TransferType};
-use crate::{
-    body_headers::encoding_info::EncodingInfo,
-    const_headers::*,
-    header_map::{HeaderMap, header::Header},
-};
-
-/* Steps:
- *      3. If header.key "Content-Length", and if body_headers.transfer_type is
- *         not set then convert content length to TransferType by calling
- *         cl_to_transfer_type()
- *
- *      4. If header.key is "te" or "Transfer-Encoding",
- *          a. build Vec<TransferEncoding> by calling match_compression() with
- *          header.value_as_str().
- *
- *          b. If chunked value is present, remove it and set transfer_type to
- *          TansferType of chunked
- *
- *      5. If header.key is "ce" or "Content-Encoding", set
- *         body_header.content_encoding to vec built by calling
- *         match_compression() with header.value_as_str().
- *
- *      6. If header.key is "ct" or "Content-Type", split at "/" to get
- *         main content type. Use From<&str> for ContentType to create
- *         ContentType from string. Assign to body_header.content_type.
- *
- *      7. If TransferType is Unknown, and if content_encoding or
- *         transfer_encoding or content_type is present, then set TransferType
- *         to Close
- *
- *      8. Call sanitize() on BodyHeader to remove empty values.
- */
+use crate::{Header, HeaderMap, body_headers::encoding_info::EncodingInfo, const_headers::*};
 
 impl From<&HeaderMap> for Option<BodyHeader> {
     fn from(header_map: &HeaderMap) -> Self {
diff --git a/header-plz/src/body_headers/mod.rs b/header-plz/src/body_headers/mod.rs
@@ -41,7 +41,7 @@ impl BodyHeader {
             .as_ref()
             .map(|list| {
                 list.iter()
-                    .any(|ei| ei.encoding == ContentEncoding::Chunked)
+                    .any(|ei| *ei.encoding() == ContentEncoding::Chunked)
             })
             .unwrap_or(false)
     }
diff --git a/header-plz/src/body_headers/parse.rs b/header-plz/src/body_headers/parse.rs
@@ -1,7 +1,7 @@
 use tracing::error;
 
 use crate::{
-    info_line::{request::Request, response::Response},
+    Request, Response,
     message_head::MessageHead,
     methods::{METHODS_WITH_BODY, Method},
 };
diff --git a/header-plz/src/error.rs b/header-plz/src/error.rs
@@ -1,7 +1,8 @@
-use crate::info_line::error::InfoLineError;
 use std::fmt::Debug;
 use thiserror::Error;
 
+use crate::message_head::info_line::error::InfoLineError;
+
 #[derive(Debug, Error)]
 pub enum HeaderReadError {
     #[error("infoline| {0}")]
diff --git a/header-plz/src/lib.rs b/header-plz/src/lib.rs
@@ -4,8 +4,9 @@ pub mod abnf;
 pub mod body_headers;
 pub mod const_headers;
 pub mod error;
-pub mod header_map;
-pub mod info_line;
 pub mod message_head;
 pub mod methods;
-pub mod reader;
+
+pub use message_head::header_map::HeaderMap;
+pub use message_head::header_map::header::Header;
+pub use message_head::info_line::{request::Request, response::Response};
diff --git a/header-plz/src/message_head/header_map/from_bytes.rs b/header-plz/src/message_head/header_map/from_bytes.rs
diff --git a/header-plz/src/message_head/header_map/header/from_bytes.rs b/header-plz/src/message_head/header_map/header/from_bytes.rs
@@ -18,12 +18,6 @@ pub fn find_header_fs(input: &str) -> usize {
 
 /* Description:
  *      Contains atleast CRLF.
- *
- * Steps:
- *      1. Find ": " index.
- *      2. If no ": " found, split at index 1 as atleast CRLF if
- *         present.
- *      2. Split to key and value.
  */
 impl From<BytesMut> for Header {
     fn from(mut input: BytesMut) -> Self {
diff --git a/header-plz/src/message_head/header_map/header/from_str.rs b/header-plz/src/message_head/header_map/header/from_str.rs
@@ -1,16 +1,9 @@
 use super::*;
 use crate::{
     abnf::{CRLF, HEADER_FS},
-    header_map::header::from_bytes::find_header_fs,
+    message_head::header_map::header::from_bytes::find_header_fs,
 };
 
-/* Steps:
- *      1. Convert str to BytesMut
- *      2. Extend key with ": "
- *      3. Extend value with CRLF
- *      4. Return Header
- */
-
 // (Content-Type, application/json)
 impl From<(&str, &str)> for Header {
     fn from((key, value): (&str, &str)) -> Self {
diff --git a/header-plz/src/message_head/header_map/header/mod.rs b/header-plz/src/message_head/header_map/header/mod.rs
diff --git a/header-plz/src/message_head/header_map/mod.rs b/header-plz/src/message_head/header_map/mod.rs
@@ -150,11 +150,16 @@ impl HeaderMap {
         self.find_pos(|h| h.key_as_str().eq_ignore_ascii_case(key))
     }
 
+    // ----- key -> value
     pub fn value_of_key(&self, key: &str) -> Option<&str> {
         self.find_pos(|h| h.key_as_str().eq_ignore_ascii_case(key))
             .map(|pos| self.headers[pos].value_as_str())
     }
 
+    pub fn is_empty_value(&self, index: usize) -> bool {
+        self.headers[index].value_as_str().is_empty()
+    }
+
     // ----- update
     pub fn update_header_key_all(&mut self, old_key: &str, new_key: &str) -> bool {
         let mut result = false;
diff --git a/header-plz/src/message_head/info_line/error.rs b/header-plz/src/message_head/info_line/error.rs
diff --git a/header-plz/src/message_head/info_line/mod.rs b/header-plz/src/message_head/info_line/mod.rs
diff --git a/header-plz/src/message_head/info_line/request.rs b/header-plz/src/message_head/info_line/request.rs
@@ -180,38 +180,38 @@ mod tests {
     }
 
     /*
-        #[test]
-        fn it_should_return_first_line_query_params() {
-            let raw = HttpRaw::new(b"GET /users?param=value&param2=value2 HTTP/1.1\r\n\r\n".to_vec());
-            let mut params = raw.first_line().unwrap().query().unwrap().params();
-            assert_eq!(2, params.len());
-
-            let param2 = params.pop().unwrap();
-            let param2_raw = param2.raw();
-            assert_eq!(b"param2=value2", param2_raw.data);
-            assert_eq!(Bound::Included(&23), param2_raw.range.start_bound());
-            assert_eq!(Bound::Excluded(&36), param2_raw.range.end_bound());
-            let param2_parts = param2.parts().unwrap();
-            assert_eq!(b"param2", param2_parts.0.data);
-            assert_eq!(Bound::Included(&23), param2_parts.0.range.start_bound());
-            assert_eq!(Bound::Excluded(&29), param2_parts.0.range.end_bound());
-            assert_eq!(b"value2", param2_parts.1.data);
-            assert_eq!(Bound::Included(&30), param2_parts.1.range.start_bound());
-            assert_eq!(Bound::Excluded(&36), param2_parts.1.range.end_bound());
-
-            let param1 = params.pop().unwrap();
-            let param1_raw = param1.raw();
-            assert_eq!(b"param=value", param1_raw.data);
-            assert_eq!(Bound::Included(&11), param1_raw.range.start_bound());
-            assert_eq!(Bound::Excluded(&22), param1_raw.range.end_bound());
-            let param1_parts = param1.parts().unwrap();
-            assert_eq!(b"param", param1_parts.0.data);
-            assert_eq!(Bound::Included(&11), param1_parts.0.range.start_bound());
-            assert_eq!(Bound::Excluded(&16), param1_parts.0.range.end_bound());
-            assert_eq!(b"value", param1_parts.1.data);
-            assert_eq!(Bound::Included(&17), param1_parts.1.range.start_bound());
-            assert_eq!(Bound::Excluded(&22), param1_parts.1.range.end_bound());
-        }
+    #[test]
+    fn it_should_return_first_line_query_params() {
+        let raw = HttpRaw::new(b"GET /users?param=value&param2=value2 HTTP/1.1\r\n\r\n".to_vec());
+        let mut params = raw.first_line().unwrap().query().unwrap().params();
+        assert_eq!(2, params.len());
+
+        let param2 = params.pop().unwrap();
+        let param2_raw = param2.raw();
+        assert_eq!(b"param2=value2", param2_raw.data);
+        assert_eq!(Bound::Included(&23), param2_raw.range.start_bound());
+        assert_eq!(Bound::Excluded(&36), param2_raw.range.end_bound());
+        let param2_parts = param2.parts().unwrap();
+        assert_eq!(b"param2", param2_parts.0.data);
+        assert_eq!(Bound::Included(&23), param2_parts.0.range.start_bound());
+        assert_eq!(Bound::Excluded(&29), param2_parts.0.range.end_bound());
+        assert_eq!(b"value2", param2_parts.1.data);
+        assert_eq!(Bound::Included(&30), param2_parts.1.range.start_bound());
+        assert_eq!(Bound::Excluded(&36), param2_parts.1.range.end_bound());
+
+        let param1 = params.pop().unwrap();
+        let param1_raw = param1.raw();
+        assert_eq!(b"param=value", param1_raw.data);
+        assert_eq!(Bound::Included(&11), param1_raw.range.start_bound());
+        assert_eq!(Bound::Excluded(&22), param1_raw.range.end_bound());
+        let param1_parts = param1.parts().unwrap();
+        assert_eq!(b"param", param1_parts.0.data);
+        assert_eq!(Bound::Included(&11), param1_parts.0.range.start_bound());
+        assert_eq!(Bound::Excluded(&16), param1_parts.0.range.end_bound());
+        assert_eq!(b"value", param1_parts.1.data);
+        assert_eq!(Bound::Included(&17), param1_parts.1.range.start_bound());
+        assert_eq!(Bound::Excluded(&22), param1_parts.1.range.end_bound());
+    }
 
 
 
diff --git a/header-plz/src/message_head/info_line/response.rs b/header-plz/src/message_head/info_line/response.rs
diff --git a/header-plz/src/message_head/mod.rs b/header-plz/src/message_head/mod.rs
@@ -1,7 +1,15 @@
-use crate::{header_map::HeaderMap, info_line::InfoLine};
+use buffer_plz::Cursor;
 use bytes::BytesMut;
+use header_map::HeaderMap;
+use info_line::InfoLine;
+
+use crate::abnf::HEADER_DELIMITER;
+
 mod try_from_bytes;
 
+pub mod header_map;
+pub mod info_line;
+
 // Represent the Header region Infoline + HeaderMap.
 #[cfg_attr(any(test, debug_assertions), derive(Debug, PartialEq, Eq))]
 pub struct MessageHead<T> {
@@ -43,3 +51,79 @@ where
         &mut self.header_map
     }
 }
+
+/* Steps:
+ *      1. Find HEADER_DELIMITER ( 2 * CRLF ).
+ *      2. If found, set buf position to index + 4 and return true.
+ *      3. If not found, check if atlease buf len is 3 to consider atleast
+ *         \r\n\r as received, set buf position to buf.len() - 3 and return
+ *         false.
+ */
+impl MessageHead<()> {
+    pub fn is_ended(buf: &mut Cursor) -> bool {
+        if let Some(index) = buf
+            .as_ref()
+            .windows(4)
+            .position(|window| window == HEADER_DELIMITER)
+        {
+            // 2. Found
+            buf.set_position(index + 4);
+            return true;
+        }
+        // 3. Considering \r\n\r as received
+        if buf.len() > 3 {
+            buf.set_position(buf.len() - 3);
+        }
+        false
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use bytes::BytesMut;
+
+    use super::*;
+
+    #[test]
+    fn test_header_reader_read_success() {
+        let req = "GET /echo HTTP/1.1\r\n\
+                    Host: reqbin.com\r\n\r\n";
+        let mut buf = BytesMut::from(req);
+        let mut cur = Cursor::new(&mut buf);
+        let verify = BytesMut::from(req);
+        let status: bool = MessageHead::is_ended(&mut cur);
+        assert!(status);
+        assert_eq!(cur.position(), verify.len());
+    }
+
+    #[test]
+    fn test_header_reader_read_fail() {
+        let req = "GET /echo HTTP/1.1\r\n\
+                    Host: reqbin.com\r\n";
+        let mut buf = BytesMut::from(req);
+        let mut cur = Cursor::new(&mut buf);
+        let status: bool = MessageHead::is_ended(&mut cur);
+        assert!(!status);
+        assert_eq!(cur.position(), req.len() - 3);
+    }
+
+    #[test]
+    fn test_header_reader_read_growth() {
+        let req = "GET /echo HTTP/1.1\r\n";
+        let mut buf = BytesMut::from(req);
+        let mut cur = Cursor::new(&mut buf);
+        let mut status = MessageHead::is_ended(&mut cur);
+        assert!(!status);
+        assert_eq!(cur.position(), req.len() - 3);
+        let toadd = b"Host: reqbin.com\r";
+        cur.as_mut().extend_from_slice(toadd);
+        status = MessageHead::is_ended(&mut cur);
+        assert!(!status);
+        assert_eq!(cur.position(), cur.as_ref().len() - 3);
+        let toadd = b"\n\r\n";
+        cur.as_mut().extend_from_slice(toadd);
+        status = MessageHead::is_ended(&mut cur);
+        assert!(status);
+        assert_eq!(cur.position(), cur.as_ref().len());
+    }
+}
diff --git a/header-plz/src/message_head/try_from_bytes.rs b/header-plz/src/message_head/try_from_bytes.rs
@@ -1,8 +1,6 @@
-use bytes::BytesMut;
-
-use crate::{error::HeaderReadError, header_map::HeaderMap, info_line::InfoLine};
-
 use super::MessageHead;
+use crate::{HeaderMap, error::HeaderReadError, message_head::info_line::InfoLine};
+use bytes::BytesMut;
 
 /* Steps:
  *      1. Find CR in buf.
@@ -38,42 +36,41 @@ where
 #[cfg(test)]
 mod tests {
 
-    use crate::info_line::{request::Request, response::Response};
+    use crate::{Request, Response};
 
     use super::*;
 
     #[test]
     fn test_message_head_request_try_from() {
-        let request = "GET / HTTP/1.1\r\n\
+        let input = "GET / HTTP/1.1\r\n\
                        Host: localhost\r\n\
                        Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n\
                        Accept-Language: en-US,en;q=0.5\r\n\
                        Accept-Encoding: gzip, deflate\r\n\
                        User-Agent: curl/7.29.0\r\n\
-                       Connection: keep-alive\r\n\r\n
-                       ";
-        let buf = BytesMut::from(request);
+                       Connection: keep-alive\r\n\r\n";
+        let buf = BytesMut::from(input);
         let org = buf.as_ptr_range();
         let result = MessageHead::<Request>::try_from(buf).unwrap();
         assert_eq!(result.info_line.method(), b"GET");
         assert_eq!(result.info_line.uri_as_string(), "/");
         let verify = result.into_bytes();
-        assert_eq!(verify, request);
+        assert_eq!(verify, input);
         assert_eq!(verify.as_ptr_range(), org);
     }
 
     #[test]
     fn test_message_head_response_try_from() {
-        let response = "HTTP/1.1 200 OK\r\n\
+        let input = "HTTP/1.1 200 OK\r\n\
                         Host: localhost\r\n\
                         Content-Type: text/plain\r\n\
                         Content-Length: 12\r\n\r\n";
-        let buf = BytesMut::from(response);
+        let buf = BytesMut::from(input);
         let org = buf.as_ptr_range();
         let result = MessageHead::<Response>::try_from(buf).unwrap();
         assert_eq!(result.info_line.status(), b"200");
         let verify = result.into_bytes();
-        assert_eq!(verify, response);
+        assert_eq!(verify, input);
         assert_eq!(verify.as_ptr_range(), org);
     }
 }
diff --git a/header-plz/src/reader.rs b/header-plz/src/reader.rs

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ use crate::body_headers::content_encoding::ContentEncoding;`
`3`	`3`	`#[cfg_attr(any(test, debug_assertions), derive(Debug, PartialEq, Eq, Clone))]`
`4`	`4`	`pub struct EncodingInfo {`
`5`	`5`	`header_index: usize,`
`6`		`- pub encoding: ContentEncoding,`
	`6`	`+ encoding: ContentEncoding,`
`7`	`7`	`}`
`8`	`8`
`9`	`9`	`impl From<(usize, ContentEncoding)> for EncodingInfo {`
`@@ -23,6 +23,10 @@ impl EncodingInfo {`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`
	`26`	`+ pub fn encoding(&self) -> &ContentEncoding {`
	`27`	`+ &self.encoding`
	`28`	`+ }`
	`29`	`+`
`26`	`30`	`pub fn iter_from_str(index: usize, val: &str) -> impl Iterator<Item = EncodingInfo> {`
`27`	`31`	`val.split(',')`
`28`	`32`	`.map(str::trim)`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ impl BodyHeader {`
`41`	`41`	`.as_ref()`
`42`	`42`	`.map(\|list\| {`
`43`	`43`	`list.iter()`
`44`		`- .any(\|ei\| ei.encoding == ContentEncoding::Chunked)`
	`44`	`+ .any(\|ei\| *ei.encoding() == ContentEncoding::Chunked)`
`45`	`45`	`})`
`46`	`46`	`.unwrap_or(false)`
`47`	`47`	`}`