Rename bridge_engine names for consistency

3 files changed, 38 insertions, 38 deletions

diff --git a/webapp/src/bridge_engine.rs b/webapp/src/bridge_engine.rs
index b13d715..0552d3f 100644
--- a/webapp/src/bridge_engine.rs
+++ b/webapp/src/bridge_engine.rs
@@ -59,19 +59,19 @@ impl Trick {
 }
 
 #[derive(PartialEq, Eq, Debug, Clone)]
-pub struct PlayTurn {
+pub struct TurnInPlay {
     trick: Trick,
 }
 
 #[derive(PartialEq, Eq, Debug)]
-pub enum PlayResult {
-    InProgress(PlayTurn),
+pub enum TurnInPlayResult {
+    InProgress(TurnInPlay),
     Trick(Trick),
 }
 
-impl PlayTurn {
-    pub fn new(p: Player) -> PlayTurn {
-        PlayTurn {
+impl TurnInPlay {
+    pub fn new(p: Player) -> TurnInPlay {
+        TurnInPlay {
             trick: Trick {
                 leader: p,
                 cards_played: Vec::with_capacity(4),
@@ -87,12 +87,12 @@ impl PlayTurn {
         &self.trick.cards_played[..]
     }
 
-    pub fn play(mut self: PlayTurn, card: Card) -> PlayResult {
+    pub fn play(mut self: TurnInPlay, card: Card) -> TurnInPlayResult {
         self.trick.cards_played.push(card);
         if self.trick.cards_played.len() >= 4 {
-            return PlayResult::Trick(self.trick);
+            return TurnInPlayResult::Trick(self.trick);
         }
-        PlayResult::InProgress(self)
+        TurnInPlayResult::InProgress(self)
     }
 
     pub fn next_player(&self) -> Player {
@@ -101,28 +101,28 @@ impl PlayTurn {
 }
 
 #[derive(Clone, Debug)]
-pub struct PlayingDeal {
+pub struct DealInPlay {
     deal: Deal,
     tricks_played: Vec<Trick>,
-    in_progress: PlayTurn,
+    in_progress: TurnInPlay,
 }
 
 #[derive(Debug)]
-pub enum PlayingDealResult {
-    InProgress(PlayingDeal),
+pub enum DealInPlayResult {
+    InProgress(DealInPlay),
     PlayFinished(Vec<Trick>),
 }
 
-impl PlayingDeal {
-    pub fn new(leader: Player, deal: Deal) -> PlayingDeal {
-        PlayingDeal {
+impl DealInPlay {
+    pub fn new(leader: Player, deal: Deal) -> DealInPlay {
+        DealInPlay {
             deal,
             tricks_played: Vec::with_capacity(13),
-            in_progress: PlayTurn::new(leader),
+            in_progress: TurnInPlay::new(leader),
         }
     }
 
-    pub fn trick_in_play(&self) -> &PlayTurn {
+    pub fn trick_in_play(&self) -> &TurnInPlay {
         &self.in_progress
     }
 
@@ -130,7 +130,7 @@ impl PlayingDeal {
         &self.deal
     }
 
-    pub fn play(mut self: Self, card: Card) -> Result<PlayingDealResult, anyhow::Error> {
+    pub fn play(mut self: Self, card: Card) -> Result<DealInPlayResult, anyhow::Error> {
         let player = self.in_progress.next_player();
         let player_cards = player.get_cards(&mut self.deal);
 
@@ -146,12 +146,12 @@ impl PlayingDeal {
         player_cards.remove(i);
 
         Ok(match self.in_progress.play(card) {
-            PlayResult::InProgress(turn) => PlayingDealResult::InProgress(Self {
+            TurnInPlayResult::InProgress(turn) => DealInPlayResult::InProgress(Self {
                 in_progress: turn,
                 ..self
             }),
-            PlayResult::Trick(trick) => PlayingDealResult::InProgress(Self {
-                in_progress: PlayTurn::new(trick.winner()),
+            TurnInPlayResult::Trick(trick) => DealInPlayResult::InProgress(Self {
+                in_progress: TurnInPlay::new(trick.winner()),
                 tricks_played: {
                     let mut tricks = self.tricks_played;
                     tricks.push(trick);
@@ -588,16 +588,16 @@ mod tests {
         assert_eq!(Player::South, Player::South.many_next(4 * 1234567890));
     }
 
-    fn as_turn(p: PlayResult) -> PlayTurn {
-        if let PlayResult::InProgress(t) = p {
+    fn as_turn(p: TurnInPlayResult) -> TurnInPlay {
+        if let TurnInPlayResult::InProgress(t) = p {
             t
         } else {
             panic!("expected PlayResult::InProgress(): {:?}", p);
         }
     }
 
-    fn as_trick(p: PlayResult) -> Trick {
-        if let PlayResult::Trick(t) = p {
+    fn as_trick(p: TurnInPlayResult) -> Trick {
+        if let TurnInPlayResult::Trick(t) = p {
             t
         } else {
             panic!("expected PlayResult::Trick(): {:?}", p);
@@ -606,7 +606,7 @@ mod tests {
 
     #[test]
     fn play_turn() {
-        let turn = PlayTurn::new(Player::South);
+        let turn = TurnInPlay::new(Player::South);
         assert_eq!(turn.next_player(), Player::South);
         let turn = as_turn(turn.play("♣4".parse().unwrap()));
         assert_eq!(turn.next_player(), Player::West);
@@ -653,10 +653,10 @@ mod tests {
         }
     }
 
-    fn as_playing_hand(result: PlayingDealResult) -> PlayingDeal {
+    fn as_playing_hand(result: DealInPlayResult) -> DealInPlay {
         match result {
-            PlayingDealResult::InProgress(r) => r,
-            PlayingDealResult::PlayFinished(_) => {
+            DealInPlayResult::InProgress(r) => r,
+            DealInPlayResult::PlayFinished(_) => {
                 panic!("expected PlayingDealResult::InProgress(): {:?}", result)
             }
         }
@@ -664,7 +664,7 @@ mod tests {
 
     #[test]
     fn play_hand() {
-        let deal = PlayingDeal::new(Player::West, mini_deal());
+        let deal = DealInPlay::new(Player::West, mini_deal());
         assert_eq!(deal.tricks_played, vec!());
         {
             let err = deal.clone().play(mkcard("♥9")).unwrap_err().to_string();
diff --git a/webapp/src/components/game.rs b/webapp/src/components/game.rs
index accdd33..91b3022 100644
--- a/webapp/src/components/game.rs
+++ b/webapp/src/components/game.rs
@@ -1,4 +1,4 @@
-use crate::bridge_engine::{self, Contract, Player, PlayingDeal, PlayingDealResult};
+use crate::bridge_engine::{self, Contract, Player, DealInPlay, DealInPlayResult};
 use crate::card;
 use crate::card::Deal;
 use crate::card::Suit;
@@ -20,7 +20,7 @@ enum GameState {
         _bidding: bridge_engine::Bidding,
     },
     Play {
-        playing_deal: PlayingDeal,
+        playing_deal: DealInPlay,
         contract: Contract,
         bidding: bridge_engine::Bidding,
     },
@@ -72,12 +72,12 @@ pub fn game() -> Html {
                 info!("Card clicked: {}", card);
                 match playing_deal.play(card) {
                     Err(err) => error!("Could not play card: {:?}", err),
-                    Ok(PlayingDealResult::InProgress(playing_deal)) => state.set(GameState::Play {
+                    Ok(DealInPlayResult::InProgress(playing_deal)) => state.set(GameState::Play {
                         playing_deal,
                         contract,
                         bidding,
                     }),
-                    Ok(PlayingDealResult::PlayFinished(tricks)) => todo!(),
+                    Ok(DealInPlayResult::PlayFinished(tricks)) => todo!(),
                 };
             }
         })
@@ -92,7 +92,7 @@ pub fn game() -> Html {
                 Callback::from(move |(contract, bidding)| {
                     state.set(match contract {
                         Some(contract) => GameState::Play {
-                            playing_deal: PlayingDeal::new(dealer, deal.clone()),
+                            playing_deal: DealInPlay::new(dealer, deal.clone()),
                             contract,
                             bidding,
                         },
diff --git a/webapp/src/components/trick_in_play.rs b/webapp/src/components/trick_in_play.rs
index 086a422..c034d20 100644
--- a/webapp/src/components/trick_in_play.rs
+++ b/webapp/src/components/trick_in_play.rs
@@ -1,5 +1,5 @@
 use yew::prelude::*;
-use crate::bridge_engine::PlayTurn;
+use crate::bridge_engine::TurnInPlay;
 use crate::components::Card;
 
 #[function_component(TrickInPlay)]
@@ -19,5 +19,5 @@ html! {
 
 #[derive(PartialEq, Properties, Clone)]
 pub struct TrickInPlayProps {
-    pub in_progress: PlayTurn,
+    pub in_progress: TurnInPlay,
 }