style(proto): fmt code

Author: 0x676e67

src/core/client/body/length.rs

@@ -1,5 +1,7 @@
 use std::fmt;
 
+use crate::core::error::Parse;
+
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub(crate) struct DecodedLength(u64);
 
@@ -45,12 +47,12 @@ impl DecodedLength {
     }
 
     /// Checks the `u64` is within the maximum allowed for content-length.
-    pub(crate) fn checked_new(len: u64) -> Result<Self, crate::core::error::Parse> {
+    pub(crate) fn checked_new(len: u64) -> Result<Self, Parse> {
         if len <= MAX_LEN {
             Ok(DecodedLength(len))
         } else {
             warn!("content-length bigger than maximum: {} > {}", len, MAX_LEN);
-            Err(crate::core::error::Parse::TooLarge)
+            Err(Parse::TooLarge)
         }
     }
 

src/core/client/proto/h1/mod.rs

@@ -1,14 +1,20 @@
+mod conn;
+mod decode;
+pub(crate) mod dispatch;
+mod encode;
+mod io;
+mod role;
+
 use bytes::BytesMut;
 use http::{HeaderMap, Method};
 use httparse::ParserConfig;
 
-//TODO: move out of h1::io
-pub(crate) use self::io::MINIMUM_MAX_BUFFER_SIZE;
 pub(crate) use self::{
     conn::Conn,
     decode::Decoder,
     dispatch::Dispatcher,
     encode::{EncodedBuf, Encoder},
+    io::MINIMUM_MAX_BUFFER_SIZE,
 };
 use crate::core::{
     client::{
@@ -18,21 +24,18 @@ use crate::core::{
     error::{Error, Parse, Result},
 };
 
-mod conn;
-mod decode;
-pub(crate) mod dispatch;
-mod encode;
-mod io;
-mod role;
-
 pub(crate) type ClientTransaction = role::Client;
 
 pub(crate) trait Http1Transaction {
     type Incoming;
+
     type Outgoing: Default;
+
     #[cfg(feature = "tracing")]
     const LOG: &'static str;
+
     fn parse(bytes: &mut BytesMut, ctx: ParseContext<'_>) -> ParseResult<Self::Incoming>;
+
     fn encode(enc: Encode<'_, Self::Outgoing>, dst: &mut Vec<u8>) -> Result<Encoder>;
 
     fn on_error(err: &Error) -> Option<MessageHead<Self::Outgoing>>;

src/core/client/proto/h1/role.rs

@@ -27,8 +27,9 @@ use crate::{
     header::{OrigHeaderMap, OrigHeaderName},
 };
 
+/// totally scientific
+const AVERAGE_HEADER_SIZE: usize = 30;
 pub(crate) const DEFAULT_MAX_HEADERS: usize = 100;
-const AVERAGE_HEADER_SIZE: usize = 30; // totally scientific
 
 macro_rules! header_name {
     ($bytes:expr) => {{
@@ -392,6 +393,7 @@ impl Client {
         trace!("neither Transfer-Encoding nor Content-Length");
         Ok(Some((DecodedLength::CLOSE_DELIMITED, false)))
     }
+
     fn set_length(head: &mut RequestHead, body: Option<BodyLength>) -> Encoder {
         let body = if let Some(body) = body {
             body
@@ -619,13 +621,13 @@ fn record_header_indices(
     bytes: &[u8],
     headers: &[httparse::Header<'_>],
     indices: &mut [MaybeUninit<HeaderIndices>],
-) -> Result<(), crate::core::error::Parse> {
+) -> Result<(), Parse> {
     let bytes_ptr = bytes.as_ptr() as usize;
 
     for (header, indices) in headers.iter().zip(indices.iter_mut()) {
         if header.name.len() >= (1 << 16) {
             debug!("header name larger than 64kb: {:?}", header.name);
-            return Err(crate::core::error::Parse::TooLarge);
+            return Err(Parse::TooLarge);
         }
         let name_start = header.name.as_ptr() as usize - bytes_ptr;
         let name_end = name_start + header.name.len();
@@ -643,7 +645,7 @@ fn record_header_indices(
 
 pub(crate) fn write_headers(headers: &HeaderMap, dst: &mut Vec<u8>) {
     for (name, value) in headers {
-        extend(dst, name.as_str().as_bytes());
+        extend(dst, name.as_ref());
         extend(dst, b": ");
         extend(dst, value.as_bytes());
         extend(dst, b"\r\n");