chore(proto): crate formatting

proto/src/handshake/client.rs

@@ -17,7 +17,10 @@ pub async fn do_client_handshake(
     writer.flush().await?;
 
     let auth = reader.read_proto().await?;
-    if !matches!(auth, BackendMessage::AuthenticationOk(AuthenticationOkData { status: 0 })) {
+    if !matches!(
+        auth,
+        BackendMessage::AuthenticationOk(AuthenticationOkData { status: 0 })
+    ) {
         return Err(ClientHandshakeError::UnexpectedAuthResponse(auth));
     }
 

proto/src/handshake/errors.rs

@@ -1,9 +1,9 @@
-use thiserror::Error;
-use tokio::io;
 use crate::message::backend::BackendMessage;
 use crate::message::errors::ProtoDeserializeError;
 use crate::reader::errors::{ProtoConsumeError, ProtoPeekError, ProtoReadError};
 use crate::writer::errors::ProtoWriteError;
+use thiserror::Error;
+use tokio::io;
 
 #[derive(Debug, Error)]
 pub enum ClientHandshakeError {

proto/src/handshake/mod.rs

@@ -1,5 +1,5 @@
-pub mod response;
-pub mod request;
 pub mod client;
-pub mod server;
 pub mod errors;
+pub mod request;
+pub mod response;
+pub mod server;

proto/src/handshake/request.rs

@@ -9,7 +9,10 @@ pub struct HandshakeRequest {
 
 impl HandshakeRequest {
     pub fn new(version: i32) -> Self {
-        Self { version, parameters: Vec::new() }
+        Self {
+            version,
+            parameters: Vec::new(),
+        }
     }
 
     pub fn parameter(mut self, key: &str, value: &str) -> Self {
@@ -20,12 +23,18 @@ impl HandshakeRequest {
 
 impl From<HandshakeRequest> for StartupMessageData {
     fn from(request: HandshakeRequest) -> Self {
-        Self { version: request.version, params: request.parameters }
+        Self {
+            version: request.version,
+            params: request.parameters,
+        }
     }
 }
 
 impl From<StartupMessageData> for HandshakeRequest {
     fn from(data: StartupMessageData) -> Self {
-        Self { version: data.version, parameters: data.params }
+        Self {
+            version: data.version,
+            parameters: data.params,
+        }
     }
 }

proto/src/handshake/server.rs

@@ -1,10 +1,7 @@
 use crate::handshake::errors::ServerHandshakeError;
 use crate::handshake::request::HandshakeRequest;
 use crate::handshake::response::HandshakeResponse;
-use crate::message::backend::{
+use crate::message::backend::{AuthenticationOkData, BackendMessage, ReadyForQueryData};
-    AuthenticationOkData, BackendMessage,
-    ReadyForQueryData,
-};
 use crate::message::special::{SpecialMessage, StartupMessageData};
 use crate::reader::frontend::FrontendProtoReader;
 use crate::writer::backend::BackendProtoWriter;

proto/src/message/backend.rs

@@ -1,9 +1,9 @@
+use crate::message::errors::{ProtoDeserializeError, ProtoSerializeError};
 use crate::message::primitive::data::MessageData;
 use crate::message::primitive::pglist::PgList;
 use crate::message::primitive::pgstring::PgString;
 use crate::message::proto_message::ProtoMessage;
 use bincode::{Decode, Encode};
-use crate::message::errors::{ProtoDeserializeError, ProtoSerializeError};
 
 #[derive(Debug)]
 pub enum BackendMessage {
@@ -362,6 +362,9 @@ mod tests {
         let data = vec![1, 2, 3];
 
         let message = BackendMessage::deserialize(variant, &data);
-        assert!(matches!(message, Err(ProtoDeserializeError::InvalidVariant(0))));
+        assert!(matches!(
+            message,
+            Err(ProtoDeserializeError::InvalidVariant(0))
+        ));
     }
 }

proto/src/message/frontend.rs

@@ -1,8 +1,8 @@
+use crate::message::errors::{ProtoDeserializeError, ProtoSerializeError};
 use crate::message::primitive::data::MessageData;
 use crate::message::primitive::pgstring::PgString;
 use crate::message::proto_message::ProtoMessage;
 use bincode::{Decode, Encode};
-use crate::message::errors::{ProtoDeserializeError, ProtoSerializeError};
 
 #[derive(Debug)]
 pub enum FrontendMessage {
@@ -41,8 +41,8 @@ pub struct QueryData {
 
 #[cfg(test)]
 mod tests {
-    use crate::message::backend::BackendMessage;
     use super::*;
+    use crate::message::backend::BackendMessage;
 
     #[test]
     fn test_symmetric_query() {
@@ -74,6 +74,9 @@ mod tests {
         let data = vec![1, 2, 3];
 
         let message = BackendMessage::deserialize(variant, &data);
-        assert!(matches!(message, Err(ProtoDeserializeError::InvalidVariant(0))));
+        assert!(matches!(
+            message,
+            Err(ProtoDeserializeError::InvalidVariant(0))
+        ));
     }
 }

proto/src/message/mod.rs

@@ -1,6 +1,6 @@
 pub mod backend;
+pub mod errors;
 pub mod frontend;
 pub mod primitive;
 pub mod proto_message;
 pub mod special;
-pub mod errors;

proto/src/message/primitive/data.rs

@@ -1,6 +1,6 @@
+use crate::message::errors::{ProtoDeserializeError, ProtoSerializeError};
 use crate::message::primitive::config::pg_proto_config;
 use bincode::{Decode, Encode};
-use crate::message::errors::{ProtoDeserializeError, ProtoSerializeError};
 
 pub trait MessageData: Sized {
     fn serialize(&self) -> Result<Vec<u8>, ProtoSerializeError>;

proto/src/reader/errors.rs

@@ -1,16 +1,13 @@
+use crate::message::errors::ProtoDeserializeError;
 use thiserror::Error;
 use tokio::io;
-use crate::message::errors::{ProtoDeserializeError};
 
 #[derive(Debug, Error)]
 pub enum ProtoReadError {
     #[error("message has invalid length, got {0}")]
     InvalidLength(i32),
     #[error("message has too much data, got {actual}, limit is {limit}")]
-    LengthOverflow {
+    LengthOverflow { limit: usize, actual: usize },
-        limit: usize,
-        actual: usize
-    },
     #[error("reading from socket failed")]
     Io(#[from] io::Error),
     #[error("deserialization of inner data failed")]
@@ -20,10 +17,7 @@ pub enum ProtoReadError {
 #[derive(Debug, Error)]
 pub enum ProtoPeekError {
     #[error("message has too much data, got {actual}, limit is {limit}")]
-    LengthOverflow {
+    LengthOverflow { limit: usize, actual: usize },
-        limit: usize,
-        actual: usize
-    },
     #[error("reading from socket failed")]
     Io(#[from] io::Error),
     #[error("deserialization of inner data failed")]
@@ -33,10 +27,7 @@ pub enum ProtoPeekError {
 #[derive(Debug, Error)]
 pub enum ProtoConsumeError {
     #[error("unexpected data length, expected {expected}, got {actual}")]
-    UnexpectedDataLength {
+    UnexpectedDataLength { expected: usize, actual: usize },
-        expected: usize,
-        actual: usize
-    },
     #[error("reading from socket failed")]
     Io(#[from] io::Error),
 }

proto/src/reader/frontend.rs

@@ -1,18 +1,21 @@
 use crate::message::frontend::FrontendMessage;
+use crate::message::primitive::data::MessageData;
 use crate::message::special::{CancelRequestData, SpecialMessage, StartupMessageData};
+use crate::reader::errors::{ProtoConsumeError, ProtoPeekError};
 use crate::reader::oneway::OneWayProtoReader;
 use crate::reader::protoreader::ProtoReader;
 use crate::reader::utils::AsyncPeek;
 use async_trait::async_trait;
 use tokio::io;
 use tokio::io::{AsyncBufRead, AsyncBufReadExt};
-use crate::message::primitive::data::MessageData;
-use crate::reader::errors::{ProtoConsumeError, ProtoPeekError};
 
 #[async_trait]
 pub trait FrontendProtoReader: OneWayProtoReader<FrontendMessage> {
     async fn peek_special_message(&mut self) -> Result<Option<SpecialMessage>, ProtoPeekError>;
-    async fn consume_special_message(&mut self, msg: &SpecialMessage) -> Result<(), ProtoConsumeError>;
+    async fn consume_special_message(
+        &mut self,
+        msg: &SpecialMessage,
+    ) -> Result<(), ProtoConsumeError>;
 }
 
 #[async_trait]
@@ -36,7 +39,10 @@ where
         Ok(None)
     }
 
-    async fn consume_special_message(&mut self, msg: &SpecialMessage) -> Result<(), ProtoConsumeError> {
+    async fn consume_special_message(
+        &mut self,
+        msg: &SpecialMessage,
+    ) -> Result<(), ProtoConsumeError> {
         Ok(match msg {
             SpecialMessage::CancelRequest(_) => consume_cancel_request(self),
             SpecialMessage::SSLRequest => consume_ssl_request(self),
@@ -159,16 +165,16 @@ where
     if size != 4 {
         return Err(ProtoConsumeError::UnexpectedDataLength {
             expected: 4,
-            actual: size
+            actual: size,
-        })
+        });
     }
 
     let length = i32::from_be_bytes([header[0], header[1], header[2], header[3]]) as usize;
     if length < 8 {
         return Err(ProtoConsumeError::UnexpectedDataLength {
             expected: 8,
-            actual: length
+            actual: length,
-        })
+        });
     }
 
     reader.inner.consume(length);

proto/src/reader/mod.rs

@@ -1,6 +1,6 @@
 pub mod backend;
+pub mod errors;
 pub mod frontend;
 pub mod oneway;
 pub mod protoreader;
 mod utils;
-pub mod errors;

proto/src/reader/oneway.rs

@@ -1,9 +1,9 @@
 use crate::message::proto_message::ProtoMessage;
+use crate::reader::errors::ProtoReadError;
 use crate::reader::protoreader::ProtoReader;
 use crate::reader::utils::AsyncPeek;
 use async_trait::async_trait;
 use tokio::io::{AsyncBufRead, AsyncReadExt};
-use crate::reader::errors::ProtoReadError;
 
 #[async_trait]
 pub trait OneWayProtoReader<T>

proto/src/writer/backend.rs

@@ -1,9 +1,9 @@
 use crate::message::backend::BackendMessage;
+use crate::writer::errors::ProtoWriteError;
 use crate::writer::oneway::OneWayProtoWriter;
 use crate::writer::protowriter::ProtoWriter;
 use async_trait::async_trait;
 use tokio::io::{AsyncWrite, AsyncWriteExt};
-use crate::writer::errors::ProtoWriteError;
 
 #[async_trait]
 pub trait BackendProtoWriter: OneWayProtoWriter<BackendMessage> {

proto/src/writer/errors.rs

@@ -1,6 +1,6 @@
+use crate::message::errors::ProtoSerializeError;
 use thiserror::Error;
 use tokio::io;
-use crate::message::errors::ProtoSerializeError;
 
 #[derive(Debug, Error)]
 pub enum ProtoWriteError {

proto/src/writer/frontend.rs

@@ -1,24 +1,33 @@
 use crate::message::frontend::FrontendMessage;
-use crate::writer::oneway::OneWayProtoWriter;
-use async_trait::async_trait;
-use tokio::io::{AsyncWrite, AsyncWriteExt};
 use crate::message::primitive::data::MessageData;
 use crate::message::special::{CancelRequestData, StartupMessageData};
 use crate::writer::errors::ProtoWriteError;
+use crate::writer::oneway::OneWayProtoWriter;
 use crate::writer::protowriter::ProtoWriter;
+use async_trait::async_trait;
+use tokio::io::{AsyncWrite, AsyncWriteExt};
 
 #[async_trait]
 pub trait FrontendProtoWriter: OneWayProtoWriter<FrontendMessage> {
-    async fn write_startup_message(&mut self, startup_message: StartupMessageData) -> Result<(), ProtoWriteError>;
+    async fn write_startup_message(
-    async fn write_cancel_request(&mut self, cancel_request: CancelRequestData) -> Result<(), ProtoWriteError>;
+        &mut self,
+        startup_message: StartupMessageData,
+    ) -> Result<(), ProtoWriteError>;
+    async fn write_cancel_request(
+        &mut self,
+        cancel_request: CancelRequestData,
+    ) -> Result<(), ProtoWriteError>;
 }
 
 #[async_trait]
 impl<W> FrontendProtoWriter for ProtoWriter<W>
 where
-    W: AsyncWrite + Unpin + Send
+    W: AsyncWrite + Unpin + Send,
 {
-    async fn write_startup_message(&mut self, startup_message: StartupMessageData) -> Result<(), ProtoWriteError> {
+    async fn write_startup_message(
+        &mut self,
+        startup_message: StartupMessageData,
+    ) -> Result<(), ProtoWriteError> {
         let data = startup_message.serialize()?;
         let length = data.len() + 4;
 
@@ -28,7 +37,10 @@ where
         Ok(())
     }
 
-    async fn write_cancel_request(&mut self, cancel_request: CancelRequestData) -> Result<(), ProtoWriteError> {
+    async fn write_cancel_request(
+        &mut self,
+        cancel_request: CancelRequestData,
+    ) -> Result<(), ProtoWriteError> {
         let data = cancel_request.serialize()?;
         let length = data.len() + 4;
 
@@ -74,20 +86,23 @@ mod tests {
         let writer = BufWriter::new(Vec::new());
         let mut writer = ProtoWriter::new(writer);
 
-        writer.write_startup_message(StartupMessageData {
+        writer
-            version: 196608,
+            .write_startup_message(StartupMessageData {
-            params: vec![
+                version: 196608,
-                ("user".into(), "postgres".into()),
+                params: vec![
-                ("database".into(), "postgres".into()),
+                    ("user".into(), "postgres".into()),
-            ],
+                    ("database".into(), "postgres".into()),
-        }).await.unwrap();
+                ],
+            })
+            .await
+            .unwrap();
 
         assert_eq!(
             writer.inner.buffer(),
             vec![
-                0, 0, 0, 40, 0, 3, 0, 0, b'u', b's', b'e', b'r', 0, b'p', b'o',
+                0, 0, 0, 40, 0, 3, 0, 0, b'u', b's', b'e', b'r', 0, b'p', b'o', b's', b't', b'g',
-                b's', b't', b'g', b'r', b'e', b's', 0, b'd', b'a', b't', b'a', b'b', b'a', b's',
+                b'r', b'e', b's', 0, b'd', b'a', b't', b'a', b'b', b'a', b's', b'e', 0, b'p', b'o',
-                b'e', 0, b'p', b'o', b's', b't', b'g', b'r', b'e', b's', 0
+                b's', b't', b'g', b'r', b'e', b's', 0
             ]
         );
     }
@@ -97,16 +112,17 @@ mod tests {
         let writer = BufWriter::new(Vec::new());
         let mut writer = ProtoWriter::new(writer);
 
-        writer.write_cancel_request(CancelRequestData {
+        writer
-            pid: 123,
+            .write_cancel_request(CancelRequestData {
-            secret: 234,
+                pid: 123,
-        }).await.unwrap();
+                secret: 234,
+            })
+            .await
+            .unwrap();
 
         assert_eq!(
             writer.inner.buffer(),
-            vec![
+            vec![0, 0, 0, 12, 0, 0, 0, 123, 0, 0, 0, 234]
-                0, 0, 0, 12, 0, 0, 0, 123, 0, 0, 0, 234
-            ]
         );
     }
 }

proto/src/writer/mod.rs

@@ -1,5 +1,5 @@
 pub mod backend;
+pub mod errors;
 pub mod frontend;
 pub mod oneway;
 pub mod protowriter;
-pub mod errors;

proto/src/writer/oneway.rs

@@ -1,8 +1,8 @@
 use crate::message::proto_message::ProtoMessage;
+use crate::writer::errors::ProtoWriteError;
 use crate::writer::protowriter::ProtoWriter;
 use async_trait::async_trait;
 use tokio::io::{AsyncWrite, AsyncWriteExt};
-use crate::writer::errors::ProtoWriteError;
 
 #[async_trait]
 pub trait OneWayProtoWriter<T>