Add table and move basic models to different source files (#4)

Author: qwexter

Cargo.lock

@@ -1,4 +1,9 @@
+use deck::{models::deck::Deck, models::table::Table};
 
 fn main() {
     println!("Here will be a card game!");
+    let mut deck = Deck::new();
+    deck.shuffle();
+    let table = Table::new(&mut deck);
+    println!("{}", table);
 }

bin/src/main.rs

@@ -4,3 +4,4 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+rand = "0.8.5"

deck/Cargo.toml

@@ -1,87 +1,4 @@
-#[derive(Debug, PartialEq, Eq)]
-pub enum Suit {
-    Hearts,
-    Diamonds,
-    Spades,
-    Clubs,
-}
+pub mod models;
 
-#[derive(Debug, PartialEq, Eq)]
-pub struct Card {
-    rank: u8, // 1-13 Ace->2->3...King
-    suit: Suit,
-    is_showed: bool,
-}
-
-impl Card {
-    pub fn new(rank: u8, suit: Suit) -> Self {
-        let card_range = 1..=13;
-        assert!(card_range.contains(&rank), "rank must be in range of cards");
-        Self {
-            rank: rank,
-            suit: suit,
-            is_showed: false,
-        }
-    }
-
-    pub fn flip(&mut self) {
-        self.is_showed = !self.is_showed;
-    }
-}
-
-pub struct Deck {
-    pub cards: Vec<Card>,
-}
-
-impl Deck {
-    pub fn new() -> Self {
-        let mut cards = Vec::new();
-        for rank in 1..=13 {
-            cards.push(Card::new(rank, Suit::Hearts));
-            cards.push(Card::new(rank, Suit::Diamonds));
-            cards.push(Card::new(rank, Suit::Spades));
-            cards.push(Card::new(rank, Suit::Clubs));
-        }
-        Deck { cards: cards }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn check_card_in_range() {
-        let suit = Suit::Hearts;
-        let rank = 1; // check an ace
-
-        let result = Card::new(rank, suit);
-
-        let expected = Card {
-            rank: 1,
-            suit: Suit::Hearts,
-            is_showed: false,
-        };
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    #[should_panic]
-    fn check_card_out_of_range() {
-        Card::new(100, Suit::Diamonds);
-    }
-
-    #[test]
-    fn check_flip() {
-        let mut card = Card::new(1, Suit::Diamonds);
-        card.flip();
-        assert_eq!(card.is_showed, true);
-    }
-
-    #[test]
-    fn check_deck_size() {
-        let deck = Deck::new();
-
-        assert_eq!(deck.cards.len(), 52);
-    }
-}
+pub use models::card::Card;
+pub use models::suit::Suit;

deck/src/lib.rs

@@ -0,0 +1,79 @@
+use crate::Suit;
+use std::fmt;
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct Card {
+    pub rank: u8, // 1-13 Ace->2->3...King
+    pub suit: Suit,
+    pub is_showed: bool,
+}
+
+impl Card {
+    pub fn new(rank: u8, suit: Suit) -> Self {
+        let card_range = 1..=13;
+        assert!(card_range.contains(&rank), "rank must be in range of cards");
+        Self {
+            rank: rank,
+            suit: suit,
+            is_showed: false,
+        }
+    }
+
+    pub fn flip(&mut self) {
+        self.is_showed = !self.is_showed;
+    }
+}
+
+impl fmt::Display for Card {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let text = if self.is_showed {
+            match self.rank {
+                1 => "A".to_string(),
+                11 => "J".to_string(),
+                12 => "Q".to_string(),
+                13 => "K".to_string(),
+                _ => self.rank.to_string(),
+            }
+        } else {
+            "XX".to_string()
+        };
+
+        if self.is_showed {
+            write!(f, "{}{}", text, self.suit)
+        } else {
+            write!(f, "{}", text)
+        }
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn check_card_in_range() {
+        let suit = Suit::Hearts;
+        let rank = 1; // check an ace
+
+        let result = Card::new(rank, suit);
+
+        let expected = Card {
+            rank: 1,
+            suit: Suit::Hearts,
+            is_showed: false,
+        };
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    #[should_panic]
+    fn check_card_out_of_range() {
+        Card::new(100, Suit::Diamonds);
+    }
+
+    #[test]
+    fn check_flip() {
+        let mut card = Card::new(1, Suit::Diamonds);
+        card.flip();
+        assert_eq!(card.is_showed, true);
+    }
+}

deck/src/models/card.rs

@@ -0,0 +1,49 @@
+use crate::Card;
+use crate::Suit;
+use rand::{seq::SliceRandom, thread_rng};
+
+pub struct Deck {
+    pub cards: Vec<Card>,
+}
+
+impl Deck {
+    pub fn new() -> Self {
+        let mut cards = Vec::new();
+        for rank in 1..=13 {
+            cards.push(Card::new(rank, Suit::Hearts));
+            cards.push(Card::new(rank, Suit::Diamonds));
+            cards.push(Card::new(rank, Suit::Spades));
+            cards.push(Card::new(rank, Suit::Clubs));
+        }
+        Deck { cards: cards }
+    }
+
+    pub fn draw(&mut self) -> Option<Card> {
+        self.cards.pop()
+    }
+
+    pub fn shuffle(&mut self) {
+        let mut rng = thread_rng();
+        self.cards.shuffle(&mut rng);
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn check_deck_size() {
+        let deck = Deck::new();
+
+        assert_eq!(deck.cards.len(), 52);
+    }
+
+    #[test]
+    fn check_deck_draw() {
+        let mut deck = Deck::new();
+        let card = deck.draw();
+        let expected = Card::new(13, Suit::Clubs);
+        assert!(card.is_some());
+        assert_eq!(expected, card.unwrap());
+    }
+}

deck/src/models/deck.rs

@@ -0,0 +1,4 @@
+pub mod card;
+pub mod deck;
+pub mod suit;
+pub mod table;