`cargo fmt`

6 files changed, 84 insertions, 30 deletions

diff --git a/protocol/src/bot.rs b/protocol/src/bot.rs
index 250731e..a85fda0 100644
--- a/protocol/src/bot.rs
+++ b/protocol/src/bot.rs
@@ -1,6 +1,9 @@
 use async_trait::async_trait;
 
-use crate::{bridge_engine::{BiddingStatePlayerView, Bid, PlayStatePlayerView}, card::Card};
+use crate::{
+    bridge_engine::{Bid, BiddingStatePlayerView, PlayStatePlayerView},
+    card::Card,
+};
 
 #[async_trait]
 pub trait BiddingBot {
diff --git a/protocol/src/bridge_engine.rs b/protocol/src/bridge_engine.rs
index 37687b8..0bc3434 100644
--- a/protocol/src/bridge_engine.rs
+++ b/protocol/src/bridge_engine.rs
@@ -109,10 +109,12 @@ impl Trick {
             }
         };
 
-        let (i, _) = self.cards_played
+        let (i, _) = self
+            .cards_played
             .iter()
             .enumerate()
-            .max_by(|&(_, c1), &(_, c2)| value(c1).cmp(&value(c2))).unwrap();
+            .max_by(|&(_, c1), &(_, c2)| value(c1).cmp(&value(c2)))
+            .unwrap();
         self.leader.many_next(i)
     }
 }
@@ -148,7 +150,10 @@ impl TurnInPlay {
         &self.trick.cards_played[..]
     }
 
-    pub fn play(mut self: TurnInPlay, card: Card) -> MoveResult<TurnInPlay, Trick> {
+    pub fn play(
+        mut self: TurnInPlay,
+        card: Card,
+    ) -> MoveResult<TurnInPlay, Trick> {
         self.trick.cards_played.push(card);
         if self.trick.cards_played.len() >= 4 {
             return MoveResult::Next(self.trick);
@@ -231,12 +236,10 @@ impl DealInPlay {
         player_cards.remove(i);
 
         Ok(match self.in_progress.play(card) {
-            MoveResult::Current(turn) => {
-                MoveResult::Current(Self {
-                    in_progress: turn,
-                    ..self
-                })
-            }
+            MoveResult::Current(turn) => MoveResult::Current(Self {
+                in_progress: turn,
+                ..self
+            }),
             MoveResult::Next(trick) => {
                 let trick_winner = trick.winner(self.trump_suit);
                 let mut tricks = self.tricks_played;
@@ -681,9 +684,7 @@ impl PlayState {
                     ..self
                 })
             }
-            MoveResult::Next(_) => {
-                PlayStateResult::PlayFinished(PlayResult)
-            }
+            MoveResult::Next(_) => PlayStateResult::PlayFinished(PlayResult),
         })
     }
 }
@@ -1307,7 +1308,9 @@ mod tests {
         assert_eq!(player_state.current_player(), play_state.current_player());
     }
 
-    fn as_playing_hand(result: MoveResult<DealInPlay, Vec<Trick>>) -> DealInPlay {
+    fn as_playing_hand(
+        result: MoveResult<DealInPlay, Vec<Trick>>,
+    ) -> DealInPlay {
         match result {
             MoveResult::Current(r) => r,
             MoveResult::Next(_) => {
diff --git a/protocol/src/card.rs b/protocol/src/card.rs
index b6b57e7..30cf822 100644
--- a/protocol/src/card.rs
+++ b/protocol/src/card.rs
@@ -8,7 +8,16 @@ use strum_macros::EnumCount;
 use strum_macros::EnumIter;
 
 #[derive(
-    PartialOrd, Ord, PartialEq, Eq, Clone, Copy, EnumIter, EnumCount, Serialize, Deserialize,
+    PartialOrd,
+    Ord,
+    PartialEq,
+    Eq,
+    Clone,
+    Copy,
+    EnumIter,
+    EnumCount,
+    Serialize,
+    Deserialize,
 )]
 pub enum Suit {
     Club,
@@ -17,7 +26,17 @@ pub enum Suit {
     Spade,
 }
 
-#[derive(PartialOrd, Ord, PartialEq, Eq, Clone, Copy, EnumIter, Serialize, Deserialize)]
+#[derive(
+    PartialOrd,
+    Ord,
+    PartialEq,
+    Eq,
+    Clone,
+    Copy,
+    EnumIter,
+    Serialize,
+    Deserialize,
+)]
 pub enum Rank {
     Two = 2,
     Three,
@@ -35,7 +54,10 @@ pub enum Rank {
 }
 
 impl fmt::Display for Suit {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::result::Result<(), std::fmt::Error> {
         f.write_str(match self {
             Suit::Club => "♣",
             Suit::Diamond => "♢",
@@ -66,13 +88,19 @@ impl std::str::FromStr for Suit {
 }
 
 impl fmt::Debug for Suit {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::result::Result<(), std::fmt::Error> {
         write!(f, "{}", self)
     }
 }
 
 impl fmt::Display for Rank {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::result::Result<(), std::fmt::Error> {
         f.write_str(match self {
             Rank::Ace => "A",
             Rank::King => "K",
@@ -92,7 +120,10 @@ impl fmt::Display for Rank {
 }
 
 impl fmt::Debug for Rank {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::result::Result<(), std::fmt::Error> {
         write!(f, "{}", self)
     }
 }
@@ -125,19 +156,29 @@ impl std::str::FromStr for Rank {
 pub struct Card(pub Suit, pub Rank);
 
 impl Card {
-    pub fn suit(&self) -> Suit { self.0 }
-    pub fn rank(&self) -> Rank { self.1 }
+    pub fn suit(&self) -> Suit {
+        self.0
+    }
+    pub fn rank(&self) -> Rank {
+        self.1
+    }
 }
 
 impl fmt::Display for Card {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::result::Result<(), std::fmt::Error> {
         let Card(suit, rank) = self;
         write!(f, "{}{}", suit, rank)
     }
 }
 
 impl fmt::Debug for Card {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+    fn fmt(
+        &self,
+        f: &mut std::fmt::Formatter<'_>,
+    ) -> std::result::Result<(), std::fmt::Error> {
         write!(f, "{}", self)
     }
 }
diff --git a/protocol/src/lib.rs b/protocol/src/lib.rs
index 3fbf1e0..8ae9a36 100644
--- a/protocol/src/lib.rs
+++ b/protocol/src/lib.rs
@@ -1,10 +1,10 @@
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
-pub mod card;
-pub mod bridge_engine;
 pub mod bot;
-pub mod simple_bots;
+pub mod bridge_engine;
+pub mod card;
 pub mod play_result;
+pub mod simple_bots;
 
 #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
 pub struct UserInfo {
@@ -23,6 +23,10 @@ mod tests {
 
     pub fn test_setup() {
         dotenv::dotenv().ok();
-        let _ =env_logger::Builder::from_env(Env::default().default_filter_or("info")).is_test(true).try_init();
+        let _ = env_logger::Builder::from_env(
+            Env::default().default_filter_or("info"),
+        )
+        .is_test(true)
+        .try_init();
     }
 }
diff --git a/protocol/src/play_result.rs b/protocol/src/play_result.rs
index 2dba276..8dad6ef 100644
--- a/protocol/src/play_result.rs
+++ b/protocol/src/play_result.rs
@@ -1,4 +1,4 @@
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
 pub enum MoveResult<Current, Next> {
diff --git a/protocol/src/simple_bots.rs b/protocol/src/simple_bots.rs
index 8612e64..2c2832c 100644
--- a/protocol/src/simple_bots.rs
+++ b/protocol/src/simple_bots.rs
@@ -162,7 +162,10 @@ mod tests {
         let mut result = PlayStateResult::InProgress(example_play_state());
         while let PlayStateResult::InProgress(play_state) = result {
             info!("Play state: {play_state:#?}");
-            let player_state = PlayStatePlayerView::from_play_state(&play_state, play_state.current_player());
+            let player_state = PlayStatePlayerView::from_play_state(
+                &play_state,
+                play_state.current_player(),
+            );
             let card = bot.play(&player_state).await;
             result = play_state.play(card).unwrap();
         }