fmt (#34)

Author: carllerche

examples/sub.rs

@@ -24,13 +24,15 @@ pub async fn main() -> Result<()> {
     // Open a connection to the mini-redis address.
     let client = client::connect("127.0.0.1:6379").await?;
 
-
     // subscribe to channel foo
     let mut subscriber = client.subscribe(vec!["foo".into()]).await?;
 
     // await messages on channel foo
     if let Some(msg) = subscriber.next_message().await? {
-        println!("got message from the channel: {}; message = {:?}", msg.channel, msg.content);
+        println!(
+            "got message from the channel: {}; message = {:?}",
+            msg.channel, msg.content
+        );
     }
 
     Ok(())

src/bin/cli.rs

@@ -24,7 +24,7 @@ enum Command {
     /// Get the value of key.
     Get {
         /// Name of key to get
-        key: String
+        key: String,
     },
     /// Set key to hold the string value.
     Set {
@@ -76,11 +76,19 @@ async fn main() -> mini_redis::Result<()> {
                 println!("(nil)");
             }
         }
-        Command::Set { key, value, expires: None } => {
+        Command::Set {
+            key,
+            value,
+            expires: None,
+        } => {
             client.set(&key, value).await?;
             println!("OK");
         }
-        Command::Set { key, value, expires: Some(expires) } => {
+        Command::Set {
+            key,
+            value,
+            expires: Some(expires),
+        } => {
             client.set_expires(&key, value, expires).await?;
             println!("OK");
         }

src/client.rs

@@ -5,13 +5,13 @@
 use crate::cmd::{Get, Publish, Set, Subscribe, Unsubscribe};
 use crate::{Connection, Frame};
 
+use async_stream::try_stream;
 use bytes::Bytes;
 use std::io::{Error, ErrorKind};
 use std::time::Duration;
 use tokio::net::{TcpStream, ToSocketAddrs};
 use tokio::stream::Stream;
 use tracing::{debug, instrument};
-use async_stream::try_stream;
 
 /// Established connection with a Redis server.
 ///
@@ -416,7 +416,8 @@ impl Subscriber {
         self.client.subscribe_cmd(channels).await?;
 
         // Update the set of subscribed channels.
-        self.subscribed_channels.extend(channels.iter().map(Clone::clone));
+        self.subscribed_channels
+            .extend(channels.iter().map(Clone::clone));
 
         Ok(())
     }
@@ -462,7 +463,7 @@ impl Subscriber {
                         if self.subscribed_channels.len() != len - 1 {
                             return Err(response.to_error());
                         }
-                    },
+                    }
                     _ => return Err(response.to_error()),
                 },
                 frame => return Err(frame.to_error()),

src/cmd/get.rs

@@ -17,7 +17,9 @@ pub struct Get {
 impl Get {
     /// Create a new `Get` command which fetches `key`.
     pub(crate) fn new(key: impl ToString) -> Get {
-        Get { key: key.to_string() }
+        Get {
+            key: key.to_string(),
+        }
     }
 
     /// Parse a `Get` instance from a received frame.

src/cmd/mod.rs

@@ -25,7 +25,7 @@ pub(crate) enum Command {
     Set(Set),
     Subscribe(Subscribe),
     Unsubscribe(Unsubscribe),
-    Unknown(Unknown)
+    Unknown(Unknown),
 }
 
 impl Command {
@@ -66,7 +66,7 @@ impl Command {
                 // the command is not recognized, there is most likely
                 // unconsumed fields remaining in the `Parse` instance.
                 return Ok(Command::Unknown(Unknown::new(command_name)));
-            },
+            }
         };
 
         // Check if there is any remaining unconsumed fields in the `Parse`

src/cmd/set.rs

@@ -1,5 +1,5 @@
-use crate::{Connection, Db, Frame};
 use crate::cmd::{Parse, ParseError};
+use crate::{Connection, Db, Frame};
 
 use bytes::Bytes;
 use std::time::Duration;

src/cmd/subscribe.rs

@@ -27,7 +27,9 @@ pub struct Unsubscribe {
 impl Subscribe {
     /// Creates a new `Subscribe` command to listen on the specified channels.
     pub(crate) fn new(channels: &[String]) -> Subscribe {
-        Subscribe { channels: channels.to_vec() }
+        Subscribe {
+            channels: channels.to_vec(),
+        }
     }
 
     /// Parse a `Subscribe` instance from a received frame.
@@ -221,7 +223,9 @@ impl Subscribe {
 impl Unsubscribe {
     /// Create a new `Unsubscribe` command with the given `channels`.
     pub(crate) fn new(channels: &[String]) -> Unsubscribe {
-        Unsubscribe { channels: channels.to_vec() }
+        Unsubscribe {
+            channels: channels.to_vec(),
+        }
     }
 
     /// Parse a `Unsubscribe` instance from a received frame.

src/cmd/unknown.rs

@@ -12,7 +12,9 @@ impl Unknown {
     /// Create a new `Unknown` command which responds to unknown commands
     /// issued by clients
     pub(crate) fn new(key: impl ToString) -> Unknown {
-        Unknown { command_name: key.to_string() }
+        Unknown {
+            command_name: key.to_string(),
+        }
     }
 
     /// Returns the command name

src/connection.rs

@@ -54,7 +54,7 @@ impl Connection {
     /// # Returns
     ///
     /// On success, the received frame is returned. If the `TcpStream`
-    /// is closed in a way that doesn't break a frame in half, it retuns 
+    /// is closed in a way that doesn't break a frame in half, it retuns
     /// `None`. Otherwise, an error is returned.
     pub(crate) async fn read_frame(&mut self) -> crate::Result<Option<Frame>> {
         use frame::Error::Incomplete;

src/parse.rs

@@ -67,7 +67,11 @@ impl Parse {
             Frame::Bulk(data) => str::from_utf8(&data[..])
                 .map(|s| s.to_string())
                 .map_err(|_| "protocol error; invalid string".into()),
-            frame => Err(format!("protocol error; expected simple frame or bulk frame, got {:?}", frame).into()),
+            frame => Err(format!(
+                "protocol error; expected simple frame or bulk frame, got {:?}",
+                frame
+            )
+            .into()),
         }
     }
 
@@ -83,7 +87,11 @@ impl Parse {
             // raw bytes, they are considered separate types.
             Frame::Simple(s) => Ok(Bytes::from(s.into_bytes())),
             Frame::Bulk(data) => Ok(data),
-            frame => Err(format!("protocol error; expected simple frame or bulk frame, got {:?}", frame).into()),
+            frame => Err(format!(
+                "protocol error; expected simple frame or bulk frame, got {:?}",
+                frame
+            )
+            .into()),
         }
     }
 
@@ -135,13 +143,10 @@ impl From<&str> for ParseError {
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            ParseError::EndOfStream => {
-                "protocol error; unexpected end of stream".fmt(f)
-            }
+            ParseError::EndOfStream => "protocol error; unexpected end of stream".fmt(f),
             ParseError::Other(err) => err.fmt(f),
         }
     }
 }
 
-impl std::error::Error for ParseError {
-}
+impl std::error::Error for ParseError {}