feat(tick): Add configurable tick option

Signed-off-by: dark0dave <[email protected]>

Author: dark0dave

README.md

@@ -333,6 +333,16 @@ These flags work for either of the above commands
 
   > Example: --timeout 7200 (2 hours)
 
+* -i, --tick <TICK>
+
+
+  > What it does: This sets how long the program will wait between polling weidu.
+
+  > How to use it: Replace <TIMEOUT> with a number of milliseconds.
+
+  > Default: 500 (1/2 a second)
+
+  > Example: --tick 1000
 
 * -u, --weidu-log-mode <WEIDU_LOG_MODE>
 

src/config/args.rs

@@ -118,7 +118,7 @@ pub(crate) struct Eet {
     pub(crate) options: Options,
 }
 
-#[derive(Parser, Debug, PartialEq, Clone)]
+#[derive(Parser, Debug, PartialEq, Clone, Default)]
 pub(crate) struct Options {
     /// Absolute Path to weidu binary
     #[clap(
@@ -239,6 +239,10 @@ pub(crate) struct Options {
         value_parser = BoolishValueParser::new(),
     )]
     pub(crate) check_last_installed: bool,
+
+    /// Tick
+    #[clap(env, short = 'i', long, default_value_t = 500)]
+    pub(crate) tick: u64,
 }
 
 fn parse_weidu_log_mode(arg: &str) -> Result<String, String> {
@@ -376,6 +380,7 @@ mod tests {
                         download: true,
                         overwrite: false,
                         check_last_installed: false,
+                        tick: 500,
                     },
                 }),
             };
@@ -424,6 +429,7 @@ mod tests {
                     download: expected_flag_value,
                     overwrite: !expected_flag_value,
                     check_last_installed: !expected_flag_value,
+                    tick: 500,
                 },
                 generate_directories: false,
                 new_pre_eet_dir: None,

src/installers.rs

@@ -64,15 +64,7 @@ pub(crate) fn normal_install(
             copy_folder(mod_folder, game_directory.join(&weidu_mod.name))?;
         }
         log::info!("Installing mod {:?}", &weidu_mod);
-        match install(
-            &options.weidu_binary,
-            &game_directory,
-            parser_config.clone(),
-            weidu_mod,
-            &options.language,
-            &options.weidu_log_mode,
-            options.timeout,
-        ) {
+        match install(&game_directory, parser_config.clone(), weidu_mod, options) {
             InstallationResult::Fail(message) => {
                 return Err(format!(
                     "Failed to install mod {}, error is '{}'",

src/weidu.rs

@@ -1,6 +1,6 @@
 use std::{
     io::{BufRead, BufReader, ErrorKind, Write},
-    path::{Path, PathBuf},
+    path::Path,
     process::{Child, ChildStdout, Command, Stdio},
     sync::{
         atomic::{AtomicUsize, Ordering},
@@ -12,14 +12,12 @@ use std::{
 
 use crate::{
     component::Component,
-    config::parser_config::ParserConfig,
+    config::{args::Options, parser_config::ParserConfig},
     state::State,
     utils::{get_user_input, sleep},
     weidu_parser::parse_raw_output,
 };
 
-const TICK: u64 = 1000;
-
 fn generate_args(weidu_mod: &Component, weidu_log_mode: &str, language: &str) -> Vec<String> {
     format!("{mod_name}/{mod_tp_file} {weidu_log_mode} --force-install {component} --use-lang {game_lang} --language {mod_lang}",
         mod_name = weidu_mod.name,
@@ -41,16 +39,13 @@ pub(crate) enum InstallationResult {
 }
 
 pub(crate) fn install(
-    weidu_binary: &PathBuf,
     game_directory: &Path,
     parser_config: Arc<ParserConfig>,
     weidu_mod: &Component,
-    language: &str,
-    weidu_log_mode: &str,
-    timeout: usize,
+    options: &Options,
 ) -> InstallationResult {
-    let weidu_args = generate_args(weidu_mod, weidu_log_mode, language);
-    let mut command = Command::new(weidu_binary);
+    let weidu_args = generate_args(weidu_mod, &options.weidu_log_mode, &options.language);
+    let mut command = Command::new(options.weidu_binary.clone());
     let weidu_process = command.current_dir(game_directory).args(weidu_args);
 
     let child = weidu_process
@@ -60,13 +55,14 @@ pub(crate) fn install(
         .spawn()
         .expect("Failed to spawn weidu process");
 
-    handle_io(child, parser_config, timeout)
+    handle_io(child, parser_config, options.timeout, options.tick)
 }
 
 pub(crate) fn handle_io(
     mut child: Child,
     parser_config: Arc<ParserConfig>,
     timeout: usize,
+    tick: u64,
 ) -> InstallationResult {
     let log = Arc::new(RwLock::new(String::new()));
     let mut weidu_stdin = child.stdin.take().unwrap();
@@ -80,6 +76,7 @@ pub(crate) fn handle_io(
         wait_count.clone(),
         log.clone(),
         timeout,
+        tick,
     );
 
     loop {
@@ -133,7 +130,7 @@ pub(crate) fn handle_io(
                 std::io::stdout().flush().expect("Failed to flush stdout");
 
                 wait_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-                sleep(TICK);
+                sleep(tick);
 
                 std::io::stdout().flush().expect("Failed to flush stdout");
             }

src/weidu_parser.rs

@@ -23,6 +23,7 @@ pub(crate) fn parse_raw_output(
     wait_count: Arc<AtomicUsize>,
     log: Arc<RwLock<String>>,
     timeout: usize,
+    tick: u64,
 ) {
     let mut current_state = ParserState::LookingForInterestingOutput;
     let mut question = String::new();
@@ -98,7 +99,7 @@ pub(crate) fn parse_raw_output(
                         // there is no new weidu output and we are not waiting for any, so there is nothing to do
                     }
                 }
-                sleep(100);
+                sleep(tick);
             }
             Err(TryRecvError::Disconnected) => {
                 sender