refactor: rename 'handler' to 'printer'

SpontanCombust · SpontanCombust · commit f7484633397e · 2022-02-22T05:13:24.000+01:00
diff --git a/src/cli/response_handling.rs b/src/cli/response_handling.rs
@@ -1,49 +1,50 @@
+use colored::Colorize;
 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;
+    fn handle_response(&mut self, response: WitcherPacket, verbose_print: bool);
+    fn is_done(&self) -> bool;
 }
 
 
 
-pub(crate) struct ScriptsReloadHandler {
+pub(crate) struct ScriptsReloadPrinter {
     has_finished: bool,
     warnings: Vec<String>,
     errors: Vec<String>
 }
 
-impl ScriptsReloadHandler {
+impl ScriptsReloadPrinter {
     fn print_summary(&self) {
-        println!("{} Errors, {} Warnings\n", self.errors.len(), self.warnings.len());
+        println!("========== {} Errors, {} Warnings ==========\n", self.errors.len(), self.warnings.len());
 
         for e in &self.errors {
-            println!("{}", e);
+            println!("{}", e.red());
         }
 
         println!(""); // empty line between errors and warnings
 
         for w in &self.warnings {
-            println!("{}", w);
+            println!("{}", w.yellow());
         }
     }
 }
 
-impl Default for ScriptsReloadHandler {
+impl Default for ScriptsReloadPrinter {
     fn default() -> Self {
-        ScriptsReloadHandler {
+        ScriptsReloadPrinter {
             has_finished: false,
             warnings: Vec::new(),
             errors: Vec::new(),
         }
     }
 }
 
-impl HandleResponse for ScriptsReloadHandler {
-    fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {
+impl HandleResponse for ScriptsReloadPrinter {
+    fn handle_response(&mut self, response: WitcherPacket, verbose_print: bool) {
         let msg = scripts_reload_formatter(&response);
 
         if let Ok(response_type) = scripts_reload_response_type(&response) {
@@ -75,97 +76,97 @@ impl HandleResponse for ScriptsReloadHandler {
         }
     }
 
-    fn should_exit(&self) -> bool {
+    fn is_done(&self) -> bool {
         self.has_finished
     }
 }
 
 
 
-pub(crate) struct ScriptsExecuteHandler();
+pub(crate) struct ScriptsExecutePrinter();
 
-impl HandleResponse for ScriptsExecuteHandler {
-    fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {
+impl HandleResponse for ScriptsExecutePrinter {
+    fn handle_response(&mut self, response: WitcherPacket, verbose_print: bool) {
         if verbose_print {
             println!("{:?}", response);
         } else {
             println!("{}", scripts_execute_formatter(&response));
         }
     }
 
-    fn should_exit(&self) -> bool {
+    fn is_done(&self) -> bool {
         true // only one packet
     }
 }
 
 
 
-pub(crate) struct ScriptsRootpathHandler();
+pub(crate) struct ScriptsRootpathPrinter();
 
-impl HandleResponse for ScriptsRootpathHandler {
-    fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {
+impl HandleResponse for ScriptsRootpathPrinter {
+    fn handle_response(&mut self, response: WitcherPacket, verbose_print: bool) {
         if verbose_print {
             println!("{:?}", response);
         } else {
             println!("{}", scripts_root_path_formatter(&response));
         }
     }
 
-    fn should_exit(&self) -> bool {
+    fn is_done(&self) -> bool {
         true // only one packet
     }
 }
 
 
 
-pub(crate) struct ModlistHandler();
+pub(crate) struct ModlistPrinter();
 
-impl HandleResponse for ModlistHandler {
-    fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {
+impl HandleResponse for ModlistPrinter {
+    fn handle_response(&mut self, response: WitcherPacket, verbose_print: bool) {
         if verbose_print {
             println!("{:?}", response);
         } else {
             println!("{}", mod_list_formatter(&response));
         }
     }
 
-    fn should_exit(&self) -> bool {
+    fn is_done(&self) -> bool {
         true // only one packet
     }
 }
 
 
 
-pub(crate) struct OpcodeHandler();
+pub(crate) struct OpcodePrinter();
 
-impl HandleResponse for OpcodeHandler {
-    fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {
+impl HandleResponse for OpcodePrinter {
+    fn handle_response(&mut self, response: WitcherPacket, verbose_print: bool) {
         if verbose_print {
             println!("{:?}", response);
         } else {
             println!("{}", opcode_formatter(&response));
         }
     }
 
-    fn should_exit(&self) -> bool {
+    fn is_done(&self) -> bool {
         true // only one packet
     }
 }
 
 
 
-pub(crate) struct VarlistHandler();
+pub(crate) struct VarlistPrinter();
 
-impl HandleResponse for VarlistHandler {
-    fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {
+impl HandleResponse for VarlistPrinter {
+    fn handle_response(&mut self, response: WitcherPacket, verbose_print: bool) {
         if verbose_print {
             println!("{:?}", response);
         } else {
             println!("{}", var_list_formatter(&response));
         }
     }
 
-    fn should_exit(&self) -> bool {
+    fn is_done(&self) -> bool {
         true // only one packet
     }
 }
diff --git a/src/cli/server_subcommands.rs b/src/cli/server_subcommands.rs
@@ -2,7 +2,7 @@ use std::{thread, net::{Shutdown, TcpStream}, sync::mpsc::{Receiver, TryRecvErro
 
 use clap::Subcommand;
 
-use crate::{input_waiter::input_waiter, CliOptions, response_handling::{HandleResponse, ScriptsReloadHandler, ScriptsExecuteHandler, ScriptsRootpathHandler, ModlistHandler, OpcodeHandler, VarlistHandler}};
+use crate::{input_waiter::input_waiter, CliOptions, response_handling::{HandleResponse, ScriptsReloadPrinter, ScriptsExecutePrinter, ScriptsRootpathPrinter, ModlistPrinter, OpcodePrinter, VarlistPrinter}};
 
 /// Subcommands that require connection to game's socket and sending messages to it
 #[derive(Subcommand)]
@@ -74,33 +74,32 @@ 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 handler: Box<dyn HandleResponse>;
+            let response_handler: Box<dyn HandleResponse>;
             let p = match cmd {
                 ServerSubcommands::Reload => {
-                    //TODO maybe colored text for errors
-                    handler = Box::new(ScriptsReloadHandler::default());
+                    response_handler = Box::new(ScriptsReloadPrinter::default());
                     rw3d_core::commands::scripts_reload()
                 }
                 ServerSubcommands::Exec { cmd } => {
-                    handler = Box::new(ScriptsExecuteHandler());
+                    response_handler = Box::new(ScriptsExecutePrinter());
                     rw3d_core::commands::scripts_execute(cmd)
                 }
                 ServerSubcommands::Rootpath => {
-                    handler = Box::new(ScriptsRootpathHandler());
+                    response_handler = Box::new(ScriptsRootpathPrinter());
                     rw3d_core::commands::scripts_root_path()
                 }
                 ServerSubcommands::Modlist => {
                     //TODO would be nice to have these mod actually sorted alphabetically at least
-                    handler = Box::new(ModlistHandler());
+                    response_handler = Box::new(ModlistPrinter());
                     rw3d_core::commands::mod_list()
                 }
                 ServerSubcommands::Opcode { func_name, class_name } => {
-                    handler = Box::new(OpcodeHandler());
+                    response_handler = Box::new(OpcodePrinter());
                     rw3d_core::commands::opcode(func_name, class_name)
                 }
                 ServerSubcommands::Varlist { section, name } => {
                     //TODO would be nice to have some option to sort those values
-                    handler = Box::new(VarlistHandler());
+                    response_handler = Box::new(VarlistPrinter());
                     rw3d_core::commands::var_list(section, name)
                 }
                 // ServerSubcommands::Varset { section, name, value } => {
@@ -129,7 +128,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, handler);
+                read_responses(&mut stream, options.response_timeout, reader_rcv, options.verbose, response_handler);
 
             } else {
                 // Wait a little bit to not finish the connection abruptly
@@ -202,9 +201,9 @@ 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) => {
-                    handler.handle(packet, verbose_print);
+                    handler.handle_response(packet, verbose_print);
 
-                    if handler.should_exit() {
+                    if handler.is_done() {
                         break;
                     }
                 }

Original file line number	Diff line number	Diff line change
`@@ -1,49 +1,50 @@`
	`1`	`+use colored::Colorize;`
`1`	`2`	`use rw3d_core::packet::WitcherPacket;`
`2`	`3`	`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};`
`3`	`4`
`4`	`5`
`5`	`6`
`6`	`7`	`pub(crate) trait HandleResponse {`
`7`		`- fn handle(&mut self, response: WitcherPacket, verbose_print: bool);`
`8`		`- fn should_exit(&self) -> bool;`
	`8`	`+ fn handle_response(&mut self, response: WitcherPacket, verbose_print: bool);`
	`9`	`+ fn is_done(&self) -> bool;`
`9`	`10`	`}`
`10`	`11`
`11`	`12`
`12`	`13`
`13`		`-pub(crate) struct ScriptsReloadHandler {`
	`14`	`+pub(crate) struct ScriptsReloadPrinter {`
`14`	`15`	`has_finished: bool,`
`15`	`16`	`warnings: Vec<String>,`
`16`	`17`	`errors: Vec<String>`
`17`	`18`	`}`
`18`	`19`
`19`		`-impl ScriptsReloadHandler {`
	`20`	`+impl ScriptsReloadPrinter {`
`20`	`21`	`fn print_summary(&self) {`
`21`		`- println!("{} Errors, {} Warnings\n", self.errors.len(), self.warnings.len());`
	`22`	`+ println!("========== {} Errors, {} Warnings ==========\n", self.errors.len(), self.warnings.len());`
`22`	`23`
`23`	`24`	`for e in &self.errors {`
`24`		`- println!("{}", e);`
	`25`	`+ println!("{}", e.red());`
`25`	`26`	`}`
`26`	`27`
`27`	`28`	`println!(""); // empty line between errors and warnings`
`28`	`29`
`29`	`30`	`for w in &self.warnings {`
`30`		`- println!("{}", w);`
	`31`	`+ println!("{}", w.yellow());`
`31`	`32`	`}`
`32`	`33`	`}`
`33`	`34`	`}`
`34`	`35`
`35`		`-impl Default for ScriptsReloadHandler {`
	`36`	`+impl Default for ScriptsReloadPrinter {`
`36`	`37`	`fn default() -> Self {`
`37`		`- ScriptsReloadHandler {`
	`38`	`+ ScriptsReloadPrinter {`
`38`	`39`	`has_finished: false,`
`39`	`40`	`warnings: Vec::new(),`
`40`	`41`	`errors: Vec::new(),`
`41`	`42`	`}`
`42`	`43`	`}`
`43`	`44`	`}`
`44`	`45`
`45`		`-impl HandleResponse for ScriptsReloadHandler {`
`46`		`- fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {`
	`46`	`+impl HandleResponse for ScriptsReloadPrinter {`
	`47`	`+ fn handle_response(&mut self, response: WitcherPacket, verbose_print: bool) {`
`47`	`48`	`let msg = scripts_reload_formatter(&response);`
`48`	`49`
`49`	`50`	`if let Ok(response_type) = scripts_reload_response_type(&response) {`
`@@ -75,97 +76,97 @@ impl HandleResponse for ScriptsReloadHandler {`
`75`	`76`	`}`
`76`	`77`	`}`
`77`	`78`
`78`		`- fn should_exit(&self) -> bool {`
	`79`	`+ fn is_done(&self) -> bool {`
`79`	`80`	`self.has_finished`
`80`	`81`	`}`
`81`	`82`	`}`
`82`	`83`
`83`	`84`
`84`	`85`
`85`		`-pub(crate) struct ScriptsExecuteHandler();`
	`86`	`+pub(crate) struct ScriptsExecutePrinter();`
`86`	`87`
`87`		`-impl HandleResponse for ScriptsExecuteHandler {`
`88`		`- fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {`
	`88`	`+impl HandleResponse for ScriptsExecutePrinter {`
	`89`	`+ fn handle_response(&mut self, response: WitcherPacket, verbose_print: bool) {`
`89`	`90`	`if verbose_print {`
`90`	`91`	`println!("{:?}", response);`
`91`	`92`	`} else {`
`92`	`93`	`println!("{}", scripts_execute_formatter(&response));`
`93`	`94`	`}`
`94`	`95`	`}`
`95`	`96`
`96`		`- fn should_exit(&self) -> bool {`
	`97`	`+ fn is_done(&self) -> bool {`
`97`	`98`	`true // only one packet`
`98`	`99`	`}`
`99`	`100`	`}`
`100`	`101`
`101`	`102`
`102`	`103`
`103`		`-pub(crate) struct ScriptsRootpathHandler();`
	`104`	`+pub(crate) struct ScriptsRootpathPrinter();`
`104`	`105`
`105`		`-impl HandleResponse for ScriptsRootpathHandler {`
`106`		`- fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {`
	`106`	`+impl HandleResponse for ScriptsRootpathPrinter {`
	`107`	`+ fn handle_response(&mut self, response: WitcherPacket, verbose_print: bool) {`
`107`	`108`	`if verbose_print {`
`108`	`109`	`println!("{:?}", response);`
`109`	`110`	`} else {`
`110`	`111`	`println!("{}", scripts_root_path_formatter(&response));`
`111`	`112`	`}`
`112`	`113`	`}`
`113`	`114`
`114`		`- fn should_exit(&self) -> bool {`
	`115`	`+ fn is_done(&self) -> bool {`
`115`	`116`	`true // only one packet`
`116`	`117`	`}`
`117`	`118`	`}`
`118`	`119`
`119`	`120`
`120`	`121`
`121`		`-pub(crate) struct ModlistHandler();`
	`122`	`+pub(crate) struct ModlistPrinter();`
`122`	`123`
`123`		`-impl HandleResponse for ModlistHandler {`
`124`		`- fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {`
	`124`	`+impl HandleResponse for ModlistPrinter {`
	`125`	`+ fn handle_response(&mut self, response: WitcherPacket, verbose_print: bool) {`
`125`	`126`	`if verbose_print {`
`126`	`127`	`println!("{:?}", response);`
`127`	`128`	`} else {`
`128`	`129`	`println!("{}", mod_list_formatter(&response));`
`129`	`130`	`}`
`130`	`131`	`}`
`131`	`132`
`132`		`- fn should_exit(&self) -> bool {`
	`133`	`+ fn is_done(&self) -> bool {`
`133`	`134`	`true // only one packet`
`134`	`135`	`}`
`135`	`136`	`}`
`136`	`137`
`137`	`138`
`138`	`139`
`139`		`-pub(crate) struct OpcodeHandler();`
	`140`	`+pub(crate) struct OpcodePrinter();`
`140`	`141`
`141`		`-impl HandleResponse for OpcodeHandler {`
`142`		`- fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {`
	`142`	`+impl HandleResponse for OpcodePrinter {`
	`143`	`+ fn handle_response(&mut self, response: WitcherPacket, verbose_print: bool) {`
`143`	`144`	`if verbose_print {`
`144`	`145`	`println!("{:?}", response);`
`145`	`146`	`} else {`
`146`	`147`	`println!("{}", opcode_formatter(&response));`
`147`	`148`	`}`
`148`	`149`	`}`
`149`	`150`
`150`		`- fn should_exit(&self) -> bool {`
	`151`	`+ fn is_done(&self) -> bool {`
`151`	`152`	`true // only one packet`
`152`	`153`	`}`
`153`	`154`	`}`
`154`	`155`
`155`	`156`
`156`	`157`
`157`		`-pub(crate) struct VarlistHandler();`
	`158`	`+pub(crate) struct VarlistPrinter();`
`158`	`159`
`159`		`-impl HandleResponse for VarlistHandler {`
`160`		`- fn handle(&mut self, response: WitcherPacket, verbose_print: bool) {`
	`160`	`+impl HandleResponse for VarlistPrinter {`
	`161`	`+ fn handle_response(&mut self, response: WitcherPacket, verbose_print: bool) {`
`161`	`162`	`if verbose_print {`
`162`	`163`	`println!("{:?}", response);`
`163`	`164`	`} else {`
`164`	`165`	`println!("{}", var_list_formatter(&response));`
`165`	`166`	`}`
`166`	`167`	`}`
`167`	`168`
`168`		`- fn should_exit(&self) -> bool {`
	`169`	`+ fn is_done(&self) -> bool {`
`169`	`170`	`true // only one packet`
`170`	`171`	`}`
`171`	`172`	`}`