back-end/front-end: Rust clippy fixes/refactorings

diff --git a/back_end/src/db_handler.rs b/back_end/src/db_handler.rs
index c7183094c4815ff62a35f90a025afe000e6e3234..fcb43246f335664a8fbe5827c5dd2b691adc1a16 100644 (file)
--- a/back_end/src/db_handler.rs
+++ b/back_end/src/db_handler.rs
@@ -354,11 +354,11 @@ impl DBHandler {
         phrase: Option<String>,
     ) -> Result<u32, String> {
         let mut _conn_result = Err(String::new());
-        let conn = if conn.is_none() {
+        let conn = if let Some(c) = conn {
+            c
+        } else {
             _conn_result = self.get_conn(DBFirstRun::NotFirstRun);
             _conn_result.as_ref().unwrap()
-        } else {
-            conn.unwrap()
         };
 
         let row_result: Result<usize, _> =
@@ -404,11 +404,11 @@ impl DBHandler {
 
     fn pair_up_players(&self, conn: Option<&Connection>) -> Result<(), String> {
         let mut _conn_result = Err(String::new());
-        let conn = if conn.is_none() {
+        let conn = if let Some(c) = conn {
+            c
+        } else {
             _conn_result = self.get_conn(DBFirstRun::NotFirstRun);
             _conn_result.as_ref().unwrap()
-        } else {
-            conn.unwrap()
         };
 
         let mut to_pair: Option<u32> = None;
@@ -454,11 +454,11 @@ impl DBHandler {
 
     fn create_game(&self, conn: Option<&Connection>, players: &[u32; 2]) -> Result<u32, String> {
         let mut _conn_result = Err(String::new());
-        let conn = if conn.is_none() {
+        let conn = if let Some(c) = conn {
+            c
+        } else {
             _conn_result = self.get_conn(DBFirstRun::NotFirstRun);
             _conn_result.as_ref().unwrap()
-        } else {
-            conn.unwrap()
         };
 
         let mut game_id: u32 = thread_rng().gen();
@@ -505,11 +505,11 @@ impl DBHandler {
         }
 
         let mut _conn_result = Err(String::new());
-        let conn = if conn.is_none() {
+        let conn = if let Some(c) = conn {
+            c
+        } else {
             _conn_result = self.get_conn(DBFirstRun::NotFirstRun);
             _conn_result.as_ref().unwrap()
-        } else {
-            conn.unwrap()
         };
 
         let check_player_row = conn.query_row("SELECT games.cyan_player FROM players JOIN games where games.id = players.game_id AND players.id = ?;", [player_id], |row| row.get::<usize, u32>(0));
@@ -548,11 +548,11 @@ impl DBHandler {
         player_id: u32,
     ) -> Result<bool, String> {
         let mut _conn_result = Err(String::new());
-        let conn = if conn.is_none() {
+        let conn = if let Some(c) = conn {
+            c
+        } else {
             _conn_result = self.get_conn(DBFirstRun::NotFirstRun);
             _conn_result.as_ref().unwrap()
-        } else {
-            conn.unwrap()
         };
 
         let check_player_row: Result<u32, _> =
@@ -572,11 +572,11 @@ impl DBHandler {
         player_id: u32,
     ) -> Result<bool, String> {
         let mut _conn_result = Err(String::new());
-        let conn = if conn.is_none() {
+        let conn = if let Some(c) = conn {
+            c
+        } else {
             _conn_result = self.get_conn(DBFirstRun::NotFirstRun);
             _conn_result.as_ref().unwrap()
-        } else {
-            conn.unwrap()
         };
 
         let check_player_game_row: Result<u32, _> = conn.query_row(
@@ -596,11 +596,11 @@ impl DBHandler {
         player_id: u32,
     ) -> Result<BoardStateType, String> {
         let mut _conn_result = Err(String::new());
-        let conn = if conn.is_none() {
+        let conn = if let Some(c) = conn {
+            c
+        } else {
             _conn_result = self.get_conn(DBFirstRun::NotFirstRun);
             _conn_result.as_ref().unwrap()
-        } else {
-            conn.unwrap()
         };
 
         // TODO maybe handle "opponent_disconnected" case
@@ -671,11 +671,11 @@ impl DBHandler {
 
     fn disconnect_player(&self, conn: Option<&Connection>, player_id: u32) -> Result<(), String> {
         let mut _conn_result = Err(String::new());
-        let conn = if conn.is_none() {
+        let conn = if let Some(c) = conn {
+            c
+        } else {
             _conn_result = self.get_conn(DBFirstRun::NotFirstRun);
             _conn_result.as_ref().unwrap()
-        } else {
-            conn.unwrap()
         };
 
         let stmt_result = conn.execute("DELETE FROM players WHERE id = ?;", [player_id]);
@@ -688,11 +688,11 @@ impl DBHandler {
 
     fn clear_empty_games(&self, conn: Option<&Connection>) -> Result<(), String> {
         let mut _conn_result = Err(String::new());
-        let conn = if conn.is_none() {
+        let conn = if let Some(c) = conn {
+            c
+        } else {
             _conn_result = self.get_conn(DBFirstRun::NotFirstRun);
             _conn_result.as_ref().unwrap()
-        } else {
-            conn.unwrap()
         };
 
         // Only fails if no rows were removed, and that is not an issue
@@ -712,11 +712,11 @@ impl DBHandler {
         pos: usize,
     ) -> PlaceResultType {
         let mut _conn_result = Err(String::new());
-        let conn = if conn.is_none() {
+        let conn = if let Some(c) = conn {
+            c
+        } else {
             _conn_result = self.get_conn(DBFirstRun::NotFirstRun);
             _conn_result.as_ref().unwrap()
-        } else {
-            conn.unwrap()
         };
 
         // check if player exists
@@ -960,11 +960,11 @@ impl DBHandler {
         }
 
         let mut _conn_result = Err(String::new());
-        let conn = if conn.is_none() {
+        let conn = if let Some(c) = conn {
+            c
+        } else {
             _conn_result = self.get_conn(DBFirstRun::NotFirstRun);
             _conn_result.as_ref().unwrap()
-        } else {
-            conn.unwrap()
         };
 
         let is_cyan = status == 0;
@@ -1032,11 +1032,11 @@ impl DBHandler {
 
     fn cleanup_stale_games(&self, conn: Option<&Connection>) -> Result<(), String> {
         let mut _conn_result = Err(String::new());
-        let conn = if conn.is_none() {
+        let conn = if let Some(c) = conn {
+            c
+        } else {
             _conn_result = self.get_conn(DBFirstRun::NotFirstRun);
             _conn_result.as_ref().unwrap()
-        } else {
-            conn.unwrap()
         };
 
         conn.execute(
@@ -1050,11 +1050,11 @@ impl DBHandler {
 
     fn cleanup_stale_players(&self, conn: Option<&Connection>) -> Result<(), String> {
         let mut _conn_result = Err(String::new());
-        let conn = if conn.is_none() {
+        let conn = if let Some(c) = conn {
+            c
+        } else {
             _conn_result = self.get_conn(DBFirstRun::NotFirstRun);
             _conn_result.as_ref().unwrap()
-        } else {
-            conn.unwrap()
         };
 
         conn.execute(

diff --git a/front_end/src/yew_components.rs b/front_end/src/yew_components.rs
index fd37e72597312e3bb4710888b8d425f37c8ab30d..1f5f46cfa3678a0531c9e25bc98a9a39bae34644 100644 (file)
--- a/front_end/src/yew_components.rs
+++ b/front_end/src/yew_components.rs
@@ -282,17 +282,18 @@ impl Component for Slot {
                 current_turn,
                 phrase: _,
             } => {
-                if paired && current_side.is_some() {
-                    if current_side.as_ref().unwrap() == &current_turn {
-                        // notify Wrapper with picked slot
-                        if let Some(p) = ctx.link().get_parent() {
-                            p.clone().downcast::<Wrapper>().send_message(
-                                WrapperMsg::BackendRequest {
-                                    place: ctx.props().idx,
-                                },
-                            );
-                            return false;
-                        }
+                if paired
+                    && current_side.is_some()
+                    && current_side.as_ref().unwrap() == &current_turn
+                {
+                    // notify Wrapper with picked slot
+                    if let Some(p) = ctx.link().get_parent() {
+                        p.clone()
+                            .downcast::<Wrapper>()
+                            .send_message(WrapperMsg::BackendRequest {
+                                place: ctx.props().idx,
+                            });
+                        return false;
                     }
                 }
             }
@@ -542,29 +543,29 @@ impl Wrapper {
         let board = board_from_string(board_string.clone());
         for (idx, slot) in board.iter().enumerate() {
             let was_open =
-                element_has_class(&document, &format!("slot{}", idx), "open").unwrap_or(false);
-            element_remove_class(&document, &format!("slot{}", idx), "open").ok();
-            element_remove_class(&document, &format!("slot{}", idx), "placed").ok();
-            element_remove_class(&document, &format!("slot{}", idx), "win").ok();
-            element_remove_class(&document, &format!("slot{}", idx), "cyan").ok();
-            element_remove_class(&document, &format!("slot{}", idx), "magenta").ok();
+                element_has_class(document, &format!("slot{}", idx), "open").unwrap_or(false);
+            element_remove_class(document, &format!("slot{}", idx), "open").ok();
+            element_remove_class(document, &format!("slot{}", idx), "placed").ok();
+            element_remove_class(document, &format!("slot{}", idx), "win").ok();
+            element_remove_class(document, &format!("slot{}", idx), "cyan").ok();
+            element_remove_class(document, &format!("slot{}", idx), "magenta").ok();
             match slot.get() {
                 BoardState::Empty => {
-                    element_append_class(&document, &format!("slot{}", idx), "open").ok();
+                    element_append_class(document, &format!("slot{}", idx), "open").ok();
                 }
                 BoardState::Cyan => {
-                    element_append_class(&document, &format!("slot{}", idx), "cyan").ok();
+                    element_append_class(document, &format!("slot{}", idx), "cyan").ok();
                 }
                 BoardState::CyanWin => {
-                    element_append_class(&document, &format!("slot{}", idx), "cyan").ok();
-                    element_append_class(&document, &format!("slot{}", idx), "win").ok();
+                    element_append_class(document, &format!("slot{}", idx), "cyan").ok();
+                    element_append_class(document, &format!("slot{}", idx), "win").ok();
                 }
                 BoardState::Magenta => {
-                    element_append_class(&document, &format!("slot{}", idx), "magenta").ok();
+                    element_append_class(document, &format!("slot{}", idx), "magenta").ok();
                 }
                 BoardState::MagentaWin => {
-                    element_append_class(&document, &format!("slot{}", idx), "magenta").ok();
-                    element_append_class(&document, &format!("slot{}", idx), "win").ok();
+                    element_append_class(document, &format!("slot{}", idx), "magenta").ok();
+                    element_append_class(document, &format!("slot{}", idx), "win").ok();
                 }
             }
             let char_at_idx = board_string
@@ -573,11 +574,11 @@ impl Wrapper {
                 .expect("idx into board_string should be in range");
             if char_at_idx == 'f' || char_at_idx == 'h' {
                 if char_at_idx == 'f' {
-                    element_append_class(&document, &format!("slot{}", idx), "placed").ok();
+                    element_append_class(document, &format!("slot{}", idx), "placed").ok();
                 }
                 if was_open {
                     append_to_info_text(
-                        &document,
+                        document,
                         "info_text0",
                         &format!("<b class=\"cyan\">CyanPlayer placed at {}</b>", idx),
                         INFO_TEXT_MAX_ITEMS,
@@ -586,11 +587,11 @@ impl Wrapper {
                 }
             } else if char_at_idx == 'g' || char_at_idx == 'i' {
                 if char_at_idx == 'g' {
-                    element_append_class(&document, &format!("slot{}", idx), "placed").ok();
+                    element_append_class(document, &format!("slot{}", idx), "placed").ok();
                 }
                 if was_open {
                     append_to_info_text(
-                        &document,
+                        document,
                         "info_text0",
                         &format!("<b class=\"magenta\">MagentaPlayer placed at {}</b>", idx),
                         INFO_TEXT_MAX_ITEMS,
@@ -627,7 +628,7 @@ pub enum WrapperMsg {
 }
 
 impl WrapperMsg {
-    fn is_ai_pressed(self) -> bool {
+    fn is_ai_pressed(&self) -> bool {
         matches!(self, WrapperMsg::AIPressed(_))
     }
 }