Format all code

Author: ShreyasPrasad

.pre-commit-config.yaml

@@ -1,10 +1,22 @@
 repos:
 -   repo: local
     hooks:
-    - id: fmt-check-and-lint
-      name: fmt
-      description: Format files with cargo fmt.
+    - id: codemafia
+      name: codemafia-fmt-check
+      description: Format files with cargo fmt and perform a cargo check.
       entry: bash -c 'cd codemafia && cargo fmt && cargo check'
       language: system
       pass_filenames: false
+    - id: shared
+      name: shared-fmt-check
+      description: Format files with cargo fmt and perform a cargo check.
+      entry: bash -c 'cd shared && cargo fmt && cargo check'
+      language: system
+      pass_filenames: false
+    - id: app
+      name: app-fmt-check
+      description: Format files with cargo fmt and perform a cargo check.
+      entry: bash -c 'cd app && cargo fmt && cargo check'
+      language: system
+      pass_filenames: false
 

app/src/app.rs

@@ -11,7 +11,7 @@ pub enum Route {
     Landing,
     #[not_found]
     #[at("/404")]
-    LandingDefault
+    LandingDefault,
 }
 
 fn switch_app(routes: Route) -> Html {
@@ -32,4 +32,4 @@ pub fn app() -> Html {
             <Switch<Route> render={switch_app} />
         </BrowserRouter>
     }
-}
+}

app/src/components/layoutitem.rs

@@ -12,4 +12,4 @@ pub fn layout_item(props: &Props) -> Html {
             { for props.children.iter() }
         </div>
     }
-}
+}

app/src/components/mod.rs

@@ -1,3 +1,3 @@
 /* This module contains the app's components. */
 
-pub mod layoutitem;
+pub mod layoutitem;

app/src/config.rs

@@ -2,10 +2,10 @@
 
 pub enum AppEnvironment {
     Local,
-    Prod
+    Prod,
 }
 
 pub struct AppConfig {
     api_url: String,
-    env: AppEnvironment
-}
+    env: AppEnvironment,
+}

app/src/main.rs

@@ -4,9 +4,9 @@ use app::App;
 use yew::prelude::*;
 
 /* Declare modules. */
-mod pages;
 mod components;
+mod pages;
 
 fn main() {
     yew::Renderer::<App>::new().render();
-}
+}

app/src/pages/landing.rs

@@ -1,5 +1,5 @@
-use yew::prelude::*;
 use patternfly_yew::*;
+use yew::prelude::*;
 
 use crate::components::layoutitem::LayoutItem;
 //use codemafia::events::game::RoomCode;

app/src/pages/mod.rs

@@ -1,4 +1,4 @@
 /* This module contains the app's pages. */
 
 pub mod landing;
-pub mod room;
+pub mod room;

app/src/pages/room.rs

@@ -8,4 +8,4 @@ pub struct Props {
 #[function_component]
 pub fn Room(props: &Props) -> Html {
     html! { "Hello world" }
-}
+}

shared/src/elements/mod.rs

@@ -9,24 +9,24 @@ pub const NUM_BLACK_WORDS: usize = 1;
 pub enum WordType {
     Black,
     Normal,
-    Blue, 
-    Red
+    Blue,
+    Red,
 }
 
 #[derive(Clone, Debug, Serialize)]
 pub struct Word {
     pub text: String,
     pub word_type: WordType,
-    pub clicked: bool
+    pub clicked: bool,
 }
 
 #[derive(Debug)]
 pub struct Board {
-    pub words: Vec<Word>
+    pub words: Vec<Word>,
 }
 
 /* The complete definition of a codenames game, accessible to callers, such as the gameserver. */
 #[derive(Debug)]
 pub struct Game {
-    pub board: Board
+    pub board: Board,
 }

shared/src/events/chat.rs

@@ -4,11 +4,11 @@ use serde::Serialize;
 
 #[derive(Debug, Clone, Serialize)]
 pub enum ChatEvents {
-    ChatMessageEvent(ChatMessageEvent)
+    ChatMessageEvent(ChatMessageEvent),
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub struct ChatMessageEvent {
     pub sender: String,
     pub text: String,
-}
+}

shared/src/events/game.rs

@@ -1,49 +1,59 @@
 /* Defines the content of a game event.  */
 
+use crate::{elements::WordType, messages::game::Team, player::role::CodeMafiaRoleTitle};
 use serde::Serialize;
-use crate::{messages::game::Team, player::role::CodeMafiaRoleTitle, elements::WordType};
 
 #[derive(Debug, Clone, Serialize)]
 pub enum GameEvents {
     InSufficientPlayers,
     Board(OpaqueBoard),
     RoleUpdated(CodeMafiaRoleTitle),
-    WordHint(Team /* The team that is giving a word hint */, String /* The word hint */),
-    WordClicked(u8, /* The index of the word that was clicked */ WordType /* The transparent word type */),
-    WordSuggested(String /* The suggestor player name */, u8 /* The word that was suggested */),
+    WordHint(
+        Team,   /* The team that is giving a word hint */
+        String, /* The word hint */
+    ),
+    WordClicked(
+        u8,
+        /* The index of the word that was clicked */
+        WordType, /* The transparent word type */
+    ),
+    WordSuggested(
+        String, /* The suggestor player name */
+        u8,     /* The word that was suggested */
+    ),
     Turn(TeamTurn),
-    GameEnded(GameOutcome)
+    GameEnded(GameOutcome),
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub struct OpaqueBoard {
-    pub words: Vec<OpaqueWord>
+    pub words: Vec<OpaqueWord>,
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub struct OpaqueWord {
-   pub text: String,
-   pub color: Option<WordType>
+    pub text: String,
+    pub color: Option<WordType>,
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub struct TeamTurn {
     pub team: Team,
-    pub coordinator: String /* The PlayerId of the coordinator. */
+    pub coordinator: String, /* The PlayerId of the coordinator. */
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub struct GameOutcome {
     pub winner: Team,
-    pub condition: WinCondition
+    pub condition: WinCondition,
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub enum WinCondition {
     BlackWordSelected,
     WordsCompleted,
-    UndercoverOperativeGuessed
+    UndercoverOperativeGuessed,
 }
 
 // Create a convenience aliasing type
-pub type RoomCode = String;
+pub type RoomCode = String;

shared/src/events/mod.rs

@@ -1,21 +1,21 @@
-/* 
+/*
     Event
-    
+
     Represents an event that is distributed to one or more players that are in the game.
 */
 
+use self::{chat::ChatEvents, game::GameEvents, player::PlayerEvents, room::RoomEvents};
 use serde::Serialize;
-use self::{chat::ChatEvents, game::GameEvents, room::RoomEvents, player::PlayerEvents};
 
 pub mod chat;
 pub mod game;
-pub mod room;
 pub mod player;
+pub mod room;
 
 #[derive(Debug, Clone, Serialize)]
 pub enum EventContent {
     Chat(ChatEvents),
     Game(GameEvents),
     Room(RoomEvents),
-    Player(PlayerEvents)
+    Player(PlayerEvents),
 }

shared/src/events/player.rs

@@ -5,5 +5,5 @@ use serde::Serialize;
 #[derive(Debug, Clone, Serialize)]
 pub enum PlayerEvents {
     /* Sent to a new player connecting to the game to allow for seamless reconnects. */
-    SetPlayerIdCookie(String)
-}
+    SetPlayerIdCookie(String),
+}

shared/src/events/room.rs

@@ -6,21 +6,21 @@ use serde::Serialize;
 #[derive(Debug, Clone, Serialize)]
 pub enum RoomEvents {
     RoomState(RoomState),
-    GameStarted
+    GameStarted,
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub struct PlayerOnTeam {
     pub name: String,
     pub id: String,
     pub team: Team,
-    pub is_spymaster: bool
+    pub is_spymaster: bool,
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub struct You {
     pub name: Option<String>, /* player_name */
-    pub id: String /* player_id as str */
+    pub id: String,           /* player_id as str */
 }
 
 #[derive(Debug, Clone, Serialize)]

shared/src/lib.rs

@@ -1,9 +1,9 @@
 /*
-    This crate contains shared interfaces, definitions, and types used across the stack, thus
-    enabling easy serialization and deserialization of common structures across the frontend
-    and backend.
- */
-pub mod messages;
+   This crate contains shared interfaces, definitions, and types used across the stack, thus
+   enabling easy serialization and deserialization of common structures across the frontend
+   and backend.
+*/
+pub mod elements;
 pub mod events;
+pub mod messages;
 pub mod player;
-pub mod elements;

shared/src/messages/chat.rs

@@ -5,6 +5,5 @@ use serde::Deserialize;
 #[derive(Debug, Deserialize)]
 pub struct ChatMessage {
     pub text: String,
-    pub sender: String
+    pub sender: String,
 }
-

shared/src/messages/game.rs

@@ -1,7 +1,7 @@
 /* Defines a game message and its different actions. */
 
+use serde::{Deserialize, Serialize};
 use std::fmt;
-use serde::{Serialize, Deserialize};
 
 #[derive(Debug, Deserialize)]
 pub struct GameMessage {
@@ -10,20 +10,32 @@ pub struct GameMessage {
 
 #[derive(Debug, Deserialize)]
 pub enum GameMessageAction {
-    WordSuggested(String, /* The ID of the player suggesting the word. */ u8 /* The word that was suggested by an ally. */),
-    WordClicked(String, /* The ID of the player suggesting the word. */ u8 /* The index of the word that was clicked */),
-    WordHint(String, /* The ID of the player suggesting the word. */ String /* The word hint provided by the Spymaster at the start of their turn. */),
-    EndTurn /* Done by the coodinator for the current turn. */,
+    WordSuggested(
+        String,
+        /* The ID of the player suggesting the word. */
+        u8, /* The word that was suggested by an ally. */
+    ),
+    WordClicked(
+        String,
+        /* The ID of the player suggesting the word. */
+        u8, /* The index of the word that was clicked */
+    ),
+    WordHint(
+        String,
+        /* The ID of the player suggesting the word. */
+        String, /* The word hint provided by the Spymaster at the start of their turn. */
+    ),
+    EndTurn, /* Done by the coodinator for the current turn. */
 }
 
 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
 pub enum Team {
     Blue,
-    Red
+    Red,
 }
 
 impl fmt::Display for Team {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{:?}", self)
     }
-}
+}

shared/src/messages/mod.rs

@@ -1,19 +1,19 @@
-/* 
+/*
     Messages
-    
+
     Defines the messages that are passed to the room as valid input from any connected player.
 */
 
+use self::{chat::ChatMessage, game::GameMessage, room::RoomMessage};
 use serde::Deserialize;
-use self::{chat::ChatMessage, room::RoomMessage, game::GameMessage};
 
 pub mod chat;
-pub mod room;
 pub mod game;
+pub mod room;
 
 #[derive(Debug, Deserialize)]
 pub enum Message {
     Chat(ChatMessage),
     Room(RoomMessage),
-    Game(GameMessage)
+    Game(GameMessage),
 }