feat: support for increasing and decreasing interval

.config/config.json5

@@ -38,6 +38,8 @@
       "</>": "EnterSearchMode",
       "<t>": "SwitchNoTitle",
       "<?>": "ShowHelp",
+      "<+>": "IncreaseInterval",
+      "<->": "DecreaseInterval",
     },
     "Search": {
       "<Ctrl-d>": "Quit", // Another way to quit

src/action.rs

@@ -80,4 +80,6 @@ pub enum Action {
     UpdateLatestHistoryCount,
     ShowHelp,
     ExitHelp,
+    IncreaseInterval,
+    DecreaseInterval,
 }

src/app.rs

@@ -61,9 +61,7 @@ impl<S: Store> App<S> {
             let store_runtime_config = store.get_runtime_config()?.unwrap_or_default();
 
             RuntimeConfig {
-                interval: Duration::from_std(humantime::parse_duration(
-                    &store_runtime_config.interval,
-                )?)?,
+                interval: Duration::milliseconds(store_runtime_config.interval as i64),
                 command: store_runtime_config
                     .command
                     .split(' ')
@@ -76,10 +74,12 @@ impl<S: Store> App<S> {
                 command: cli.command.clone(),
             };
 
-            let interval =
-                humantime::format_duration(cli.interval.to_std().unwrap_or_default()).to_string();
+            let interval = cli.interval.to_std().unwrap_or_default();
             let command = cli.command.join(" ");
-            store.set_runtime_config(StoreRuntimeConfig { interval, command })?;
+            store.set_runtime_config(StoreRuntimeConfig {
+                interval: interval.as_millis() as u64,
+                command,
+            })?;
 
             runtime_config
         };
@@ -283,6 +283,27 @@ impl<S: Store> App<S> {
                         self.last_tick_key_events.drain(..);
                     }
                     Action::Quit => self.should_quit = true,
+                    Action::IncreaseInterval => {
+                        self.runtime_config.interval += Duration::milliseconds(500);
+
+                        self.store.set_runtime_config(StoreRuntimeConfig {
+                            interval: self.runtime_config.interval.num_milliseconds() as u64,
+                            command: self.runtime_config.command.join(" "),
+                        })?;
+                    }
+                    Action::DecreaseInterval => {
+                        let new_interval =
+                            self.runtime_config.interval - Duration::milliseconds(500);
+
+                        if new_interval >= chrono::Duration::milliseconds(500) {
+                            self.runtime_config.interval = new_interval;
+
+                            self.store.set_runtime_config(StoreRuntimeConfig {
+                                interval: self.runtime_config.interval.num_milliseconds() as u64,
+                                command: self.runtime_config.command.join(" "),
+                            })?;
+                        }
+                    }
                     Action::Suspend => self.should_suspend = true,
                     Action::Resume => self.should_suspend = false,
                     Action::Resize(w, h) => {

src/components/home.rs

@@ -123,6 +123,12 @@ impl Component for Home {
             Action::SetTimemachineMode(timemachine_mode) => {
                 self.set_timemachine_mode(timemachine_mode)
             }
+            Action::IncreaseInterval => {
+                self.interval_component.increase_interval();
+            }
+            Action::DecreaseInterval => {
+                self.interval_component.decrease_interval();
+            }
             Action::SetNoTitle(is_no_title) => self.is_no_title = is_no_title,
             _ => {}
         }

src/components/interval.rs

@@ -26,6 +26,18 @@ impl Interval {
             config: Config::new().unwrap(),
         }
     }
+
+    pub fn increase_interval(&mut self) {
+        self.runtime_config.interval += chrono::Duration::milliseconds(500);
+    }
+
+    pub fn decrease_interval(&mut self) {
+        let new_interval = self.runtime_config.interval - chrono::Duration::milliseconds(500);
+
+        if new_interval >= chrono::Duration::milliseconds(500) {
+            self.runtime_config.interval = new_interval;
+        }
+    }
 }
 
 impl Component for Interval {

src/config.rs

@@ -218,6 +218,8 @@ impl From<OldConfig> for Config {
         insert_keybinding(keymap.scroll_page_down, Action::ResultPageDown);
         insert_keybinding(keymap.scroll_top_of_page, Action::TopOfPage);
         insert_keybinding(keymap.scroll_bottom_of_page, Action::BottomOfPage);
+        insert_keybinding(keymap.increase_interval, Action::IncreaseInterval);
+        insert_keybinding(keymap.decrease_interval, Action::DecreaseInterval);
 
         keybindings.insert(Mode::All, all_keybindings);
 

src/old_config.rs

@@ -41,6 +41,8 @@ pub struct Keymap {
     pub scroll_page_down: Option<String>,
     pub scroll_bottom_of_page: Option<String>,
     pub scroll_top_of_page: Option<String>,
+    pub increase_interval: Option<String>,
+    pub decrease_interval: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Default)]

src/runner.rs

@@ -86,7 +86,12 @@ pub async fn run_executor<S: Store>(
             eprintln!("Failed to send result: {:?}", e);
         }
 
-        tokio::time::sleep(runtime_config.interval.to_std().unwrap()).await;
+        let interval = store
+            .get_runtime_config()?
+            .map(|config| config.interval)
+            .unwrap_or(runtime_config.interval.num_milliseconds() as u64);
+
+        tokio::time::sleep(std::time::Duration::from_millis(interval)).await;
     }
 }
 
@@ -160,9 +165,19 @@ pub async fn run_executor_precise<S: Store>(
         }
 
         let elapased = chrono::Local::now().signed_duration_since(start_time);
-        let sleep_time = runtime_config.interval.sub(elapased);
-        if let Ok(sleep_time) = sleep_time.to_std() {
-            tokio::time::sleep(sleep_time).await;
+
+        let interval = store
+            .get_runtime_config()?
+            .map(|config| config.interval)
+            .unwrap_or(runtime_config.interval.num_milliseconds() as u64);
+
+        let interval = std::time::Duration::from_millis(interval);
+
+        if let Ok(elapsed_std) = elapased.to_std() {
+            if elapsed_std < interval {
+                let sleep_time = interval - elapsed_std;
+                tokio::time::sleep(sleep_time).await;
+            }
         }
     }
 }

src/store.rs

@@ -34,6 +34,6 @@ pub struct Record {
 
 #[derive(Debug, Clone, Default)]
 pub struct RuntimeConfig {
-    pub interval: String,
+    pub interval: u64,
     pub command: String,
 }