refactor: response handling trait

Author: SpontanCombust

src/cli/cli.rs

@@ -1,6 +1,7 @@
 mod server_subcommands;
 mod local_subcommands;
 mod input_waiter;
+mod response_handling;
 
 use local_subcommands::{LocalSubcommands, handle_local_subcommand};
 use server_subcommands::{ServerSubcommands, handle_server_subcommand};

src/cli/response_handling.rs

@@ -0,0 +1,171 @@
+use rw3d_core::packet::WitcherPacket;
+use rw3d_core::utils::{scripts_execute_formatter, scripts_root_path_formatter, mod_list_formatter, opcode_formatter, var_list_formatter, scripts_reload_formatter, scripts_reload_response_type, ScriptsReloadResponseType};
+
+
+
+pub(crate) trait HandleResponse {
+    fn handle(&mut self, response: WitcherPacket, verbose_print: bool);
+    fn should_exit(&self) -> bool;
+}
+
+
+
+pub(crate) struct ScriptsReloadHandler {
+    has_finished: bool,
+    warnings: Vec<String>,
+    errors: Vec<String>
+}
+
+impl ScriptsReloadHandler {
+    fn print_summary(&self) {
+        println!("{} Errors, {} Warnings\n", self.errors.len(), self.warnings.len());
+
+        for e in &self.errors {
+            println!("{}", e);
+        }
+
+        println!(""); // empty line between errors and warnings
+
+        for w in &self.warnings {
+            println!("{}", w);
+        }
+    }
+}
+
+impl Default for ScriptsReloadHandler {
+    fn default() -> Self {
+        ScriptsReloadHandler {
+            has_finished: false,
+            warnings: Vec::new(),
+            errors: Vec::new(),
+        }
+    }
+}
+
+impl HandleResponse for ScriptsReloadHandler {
+    fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {
+        let msg = scripts_reload_formatter(&response);
+
+        if let Ok(response_type) = scripts_reload_response_type(&response) {
+            match response_type {
+                ScriptsReloadResponseType::Started => {
+                    self.has_finished = false;
+                }
+                ScriptsReloadResponseType::Warn {..} => {
+                    self.warnings.push(msg.to_string());
+                }
+                ScriptsReloadResponseType::Error {..} => {
+                    self.errors.push(msg.to_string());
+                }
+                ScriptsReloadResponseType::Finished(_) => {
+                    self.has_finished = true;
+                }
+                _ => {}
+            }
+        }
+
+        if verbose_print {
+            println!("{:?}", response);
+        } else {
+            println!("{}", msg);
+        }
+
+        if self.has_finished && ( !self.warnings.is_empty() || !self.errors.is_empty() ) {
+            self.print_summary();
+        }
+    }
+
+    fn should_exit(&self) -> bool {
+        self.has_finished
+    }
+}
+
+
+
+pub(crate) struct ScriptsExecuteHandler();
+
+impl HandleResponse for ScriptsExecuteHandler {
+    fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {
+        if verbose_print {
+            println!("{:?}", response);
+        } else {
+            println!("{}", scripts_execute_formatter(&response));
+        }
+    }
+
+    fn should_exit(&self) -> bool {
+        true // only one packet
+    }
+}
+
+
+
+pub(crate) struct ScriptsRootpathHandler();
+
+impl HandleResponse for ScriptsRootpathHandler {
+    fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {
+        if verbose_print {
+            println!("{:?}", response);
+        } else {
+            println!("{}", scripts_root_path_formatter(&response));
+        }
+    }
+
+    fn should_exit(&self) -> bool {
+        true // only one packet
+    }
+}
+
+
+
+pub(crate) struct ModlistHandler();
+
+impl HandleResponse for ModlistHandler {
+    fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {
+        if verbose_print {
+            println!("{:?}", response);
+        } else {
+            println!("{}", mod_list_formatter(&response));
+        }
+    }
+
+    fn should_exit(&self) -> bool {
+        true // only one packet
+    }
+}
+
+
+
+pub(crate) struct OpcodeHandler();
+
+impl HandleResponse for OpcodeHandler {
+    fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {
+        if verbose_print {
+            println!("{:?}", response);
+        } else {
+            println!("{}", opcode_formatter(&response));
+        }
+    }
+
+    fn should_exit(&self) -> bool {
+        true // only one packet
+    }
+}
+
+
+
+pub(crate) struct VarlistHandler();
+
+impl HandleResponse for VarlistHandler {
+    fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {
+        if verbose_print {
+            println!("{:?}", response);
+        } else {
+            println!("{}", var_list_formatter(&response));
+        }
+    }
+
+    fn should_exit(&self) -> bool {
+        true // only one packet
+    }
+}

src/cli/server_subcommands.rs

@@ -1,9 +1,8 @@
 use std::{thread, net::{Shutdown, TcpStream}, sync::mpsc::{Receiver, TryRecvError}, time::Duration, io::Write};
 
 use clap::Subcommand;
-use rw3d_core::utils::ResponseFormatter;
 
-use crate::{input_waiter::input_waiter, CliOptions};
+use crate::{input_waiter::input_waiter, CliOptions, response_handling::{HandleResponse, ScriptsReloadHandler, ScriptsExecuteHandler, ScriptsRootpathHandler, ModlistHandler, OpcodeHandler, VarlistHandler}};
 
 /// Subcommands that require connection to game's socket and sending messages to it
 #[derive(Subcommand)]
@@ -75,34 +74,33 @@ pub(crate) fn handle_server_subcommand( cmd: ServerSubcommands, options: CliOpti
             if !options.no_wait { thread::sleep( Duration::from_millis(1000) ) }
             println!("Handling the command...");
 
-            let formatter: ResponseFormatter;
+            let handler: Box<dyn HandleResponse>;
             let p = match cmd {
                 ServerSubcommands::Reload => {
-                    //TODO needs some summary and maybe colored text for errors
-                    // erros are not always displayed at the end and can be easily missed
-                    formatter = rw3d_core::utils::scripts_reload_formatter;
+                    //TODO maybe colored text for errors
+                    handler = Box::new(ScriptsReloadHandler::default());
                     rw3d_core::commands::scripts_reload()
                 }
                 ServerSubcommands::Exec { cmd } => {
-                    formatter = rw3d_core::utils::scripts_execute_formatter;
+                    handler = Box::new(ScriptsExecuteHandler());
                     rw3d_core::commands::scripts_execute(cmd)
                 }
                 ServerSubcommands::Rootpath => {
-                    formatter = rw3d_core::utils::scripts_root_path_formatter;
+                    handler = Box::new(ScriptsRootpathHandler());
                     rw3d_core::commands::scripts_root_path()
                 }
                 ServerSubcommands::Modlist => {
                     //TODO would be nice to have these mod actually sorted alphabetically at least
-                    formatter = rw3d_core::utils::mod_list_formatter;
+                    handler = Box::new(ModlistHandler());
                     rw3d_core::commands::mod_list()
                 }
                 ServerSubcommands::Opcode { func_name, class_name } => {
-                    formatter = rw3d_core::utils::opcode_formatter;
+                    handler = Box::new(OpcodeHandler());
                     rw3d_core::commands::opcode(func_name, class_name)
                 }
                 ServerSubcommands::Varlist { section, name } => {
                     //TODO would be nice to have some option to sort those values
-                    formatter = rw3d_core::utils::var_list_formatter;
+                    handler = Box::new(VarlistHandler());
                     rw3d_core::commands::var_list(section, name)
                 }
                 // ServerSubcommands::Varset { section, name, value } => {
@@ -131,7 +129,7 @@ pub(crate) fn handle_server_subcommand( cmd: ServerSubcommands, options: CliOpti
 
                 // This function can either finish by itself by the means of response timeout
                 // or be stopped by input waiter thread if that one sends him a signal
-                read_responses(&mut stream, options.response_timeout, reader_rcv, options.verbose, formatter);
+                read_responses(&mut stream, options.response_timeout, reader_rcv, options.verbose, handler);
 
             } else {
                 // Wait a little bit to not finish the connection abruptly
@@ -172,7 +170,7 @@ fn try_connect(ip: String, max_tries: u8, tries_delay_ms: u64) -> Option<TcpStre
     None
 }
 
-fn read_responses(stream: &mut TcpStream, response_timeout: i64, cancel_token: Receiver<()>, verbose_print: bool, formatter: ResponseFormatter) {
+fn read_responses(stream: &mut TcpStream, response_timeout: i64, cancel_token: Receiver<()>, verbose_print: bool, mut handler: Box<dyn HandleResponse>) {
     let mut peek_buffer = [0u8;6];
     let mut packet_available: bool;
     let mut response_wait_elapsed: i64 = 0;
@@ -204,10 +202,10 @@ fn read_responses(stream: &mut TcpStream, response_timeout: i64, cancel_token: R
         if packet_available {
             match rw3d_core::packet::WitcherPacket::from_stream(stream) {
                 Ok(packet) => {
-                    if verbose_print {
-                        println!("{:?}", packet);
-                    } else {
-                        println!("{}", formatter(&packet));
+                    handler.handle(packet, verbose_print);
+
+                    if handler.should_exit() {
+                        break;
                     }
                 }
                 Err(e) => {