From 70548d2041e0f915175448f918d912708eb358f1 Mon Sep 17 00:00:00 2001
From: ddidderr <ddidderr@paul.network>
Date: Tue, 12 Aug 2025 08:39:23 +0200
Subject: [PATCH] refactor(server): implement request handlers as methods

moved request handling logic into dedicated methods on the request handler struct for better organization and readability. this includes handlers for ping, list games, get game info, and invalid requests. game file data handler is added but not yet implemented.
---
 crates/lanspread-server/src/req.rs | 124 ++++++++++++++++-------------
 1 file changed, 69 insertions(+), 55 deletions(-)

diff --git a/crates/lanspread-server/src/req.rs b/crates/lanspread-server/src/req.rs
index 6c5acb7..cac1c57 100644
--- a/crates/lanspread-server/src/req.rs
+++ b/crates/lanspread-server/src/req.rs
@@ -44,63 +44,77 @@ impl RequestHandler {
         Ok(())
     }
 
+    fn handle_ping() -> Response {
+        Response::Pong
+    }
+
+    async fn handle_list_games(&self) -> Response {
+        let db = self.db.read().await;
+        Response::ListGames(db.all_games().into_iter().cloned().collect())
+    }
+
+    async fn handle_get_game(&self, id: String, games_folder: &Path) -> Response {
+        if self.db.read().await.get_game_by_id(&id).is_none() {
+            tracing::error!("Game not found in DB: {id}");
+            return Response::GameNotFound(id);
+        }
+
+        let game_dir = games_folder.join(&id);
+        if !game_dir.exists() {
+            tracing::error!("Game folder does not exist: {}", game_dir.display());
+            return Response::GameNotFound(id);
+        }
+
+        let mut game_files_descs: Vec<GameFileDescription> = vec![];
+
+        for entry in WalkDir::new(&game_dir)
+            .into_iter()
+            .filter_map(std::result::Result::ok)
+        {
+            match get_relative_path(games_folder, entry.path()) {
+                Ok(relative_path) => match relative_path.to_str() {
+                    Some(relative_path) => {
+                        let game_file_description = GameFileDescription {
+                            game_id: id.clone(),
+                            relative_path: relative_path.to_string(),
+                            is_dir: entry.file_type().is_dir(),
+                        };
+
+                        tracing::debug!("Found game file: {:?}", game_file_description);
+
+                        game_files_descs.push(game_file_description);
+                    }
+                    None => {
+                        tracing::error!("Failed to get relative path: {relative_path:?}",);
+                    }
+                },
+                Err(e) => {
+                    tracing::error!("Failed to get relative path: {e}");
+                }
+            }
+        }
+
+        Response::GetGame {
+            id,
+            file_descriptions: game_files_descs,
+        }
+    }
+
+    fn handle_get_game_file_data(&self) -> Response {
+        Response::InvalidRequest(Bytes::new(), "Not implemented".to_string())
+    }
+
+    fn handle_invalid(&self, data: Bytes, err_msg: String) -> Response {
+        Response::InvalidRequest(data, err_msg)
+    }
+
     pub(crate) async fn process_request(&self, request: Request, games_folder: &Path) -> Response {
         match request {
-            Request::Ping => Response::Pong,
-            Request::ListGames => {
-                let db = self.db.read().await;
-                Response::ListGames(db.all_games().into_iter().cloned().collect())
-            }
-            Request::GetGame { id } => {
-                if self.db.read().await.get_game_by_id(&id).is_none() {
-                    tracing::error!("Game not found in DB: {id}");
-                    return Response::GameNotFound(id);
-                }
-
-                let game_dir = games_folder.join(&id);
-                if !game_dir.exists() {
-                    tracing::error!("Game folder does not exist: {}", game_dir.display());
-                    return Response::GameNotFound(id);
-                }
-
-                let mut game_files_descs: Vec<GameFileDescription> = vec![];
-
-                for entry in WalkDir::new(&game_dir)
-                    .into_iter()
-                    .filter_map(std::result::Result::ok)
-                {
-                    match get_relative_path(games_folder, entry.path()) {
-                        Ok(relative_path) => match relative_path.to_str() {
-                            Some(relative_path) => {
-                                let game_file_description = GameFileDescription {
-                                    game_id: id.clone(),
-                                    relative_path: relative_path.to_string(),
-                                    is_dir: entry.file_type().is_dir(),
-                                };
-
-                                tracing::debug!("Found game file: {:?}", game_file_description);
-
-                                game_files_descs.push(game_file_description);
-                            }
-                            None => {
-                                tracing::error!("Failed to get relative path: {relative_path:?}",);
-                            }
-                        },
-                        Err(e) => {
-                            tracing::error!("Failed to get relative path: {e}");
-                        }
-                    }
-                }
-
-                Response::GetGame {
-                    id,
-                    file_descriptions: game_files_descs,
-                }
-            }
-            Request::GetGameFileData(_) => {
-                Response::InvalidRequest(Bytes::new(), "Not implemented".to_string())
-            }
-            Request::Invalid(data, err_msg) => Response::InvalidRequest(data, err_msg),
+            Request::Ping => RequestHandler::handle_ping(),
+            Request::ListGames => self.handle_list_games().await,
+            Request::GetGame { id } => self.handle_get_game(id, games_folder).await,
+            Request::GetGameFileData(_) => self.handle_get_game_file_data(),
+            Request::Invalid(data, err_msg) => self.handle_invalid(data, err_msg),
         }
     }
 }