chore: define Keybinds at config.rs (and once remove tests about configs)

Author: ynqa

src/config.rs

@@ -1,7 +1,7 @@
 use std::collections::HashSet;
 
 use crossterm::{
-    event::{KeyCode, KeyEvent, KeyModifiers},
+    event::{KeyCode, KeyModifiers},
     style::{Attribute, Attributes, Color, ContentStyle},
 };
 use derive_builder::Builder;
@@ -13,7 +13,7 @@ mod content_style;
 use content_style::{content_style_serde, option_content_style_serde};
 mod duration;
 use duration::{duration_serde, option_duration_serde};
-mod event;
+pub mod event;
 use event::{EventDefSet, KeyEventDef};
 
 #[derive(Serialize, Deserialize, Builder)]
@@ -104,19 +104,6 @@ pub(crate) struct Config {
     #[serde(with = "content_style_serde")]
     #[builder_field_attr(serde(default, with = "option_content_style_serde"))]
     pub null_value_style: ContentStyle,
-
-    pub move_to_tail: EventDefSet,
-    pub move_to_head: EventDefSet,
-    pub backward: EventDefSet,
-    pub forward: EventDefSet,
-    pub completion: EventDefSet,
-    pub move_to_next_nearest: EventDefSet,
-    pub move_to_previous_nearest: EventDefSet,
-    pub erase: EventDefSet,
-    pub erase_all: EventDefSet,
-    pub erase_to_previous_nearest: EventDefSet,
-    pub erase_to_next_nearest: EventDefSet,
-    pub search_up: EventDefSet,
 }
 
 impl Default for Config {
@@ -162,45 +149,11 @@ impl Default for Config {
             focus_active_char_style: StyleBuilder::new().bgc(Color::Magenta).build(),
             focus_inactive_char_style: StyleBuilder::new().build(),
             inactive_item_style: StyleBuilder::new().fgc(Color::Grey).build(),
-            move_to_tail: EventDefSet::from(KeyEventDef::new(
-                KeyCode::Char('e'),
-                KeyModifiers::CONTROL,
-            )),
-            move_to_head: EventDefSet::from(KeyEventDef::new(
-                KeyCode::Char('a'),
-                KeyModifiers::CONTROL,
-            )),
-            backward: EventDefSet::from(KeyEventDef::new(KeyCode::Left, KeyModifiers::NONE)),
-            forward: EventDefSet::from(KeyEventDef::new(KeyCode::Right, KeyModifiers::NONE)),
-            completion: EventDefSet::from(KeyEventDef::new(KeyCode::Tab, KeyModifiers::NONE)),
-            move_to_next_nearest: EventDefSet::from(KeyEventDef::new(
-                KeyCode::Char('f'),
-                KeyModifiers::ALT,
-            )),
-            move_to_previous_nearest: EventDefSet::from(KeyEventDef::new(
-                KeyCode::Char('b'),
-                KeyModifiers::ALT,
-            )),
-            erase: EventDefSet::from(KeyEventDef::new(KeyCode::Backspace, KeyModifiers::NONE)),
-            erase_all: EventDefSet::from(KeyEventDef::new(
-                KeyCode::Char('u'),
-                KeyModifiers::CONTROL,
-            )),
-            erase_to_previous_nearest: EventDefSet::from(KeyEventDef::new(
-                KeyCode::Char('w'),
-                KeyModifiers::CONTROL,
-            )),
-            erase_to_next_nearest: EventDefSet::from(KeyEventDef::new(
-                KeyCode::Char('d'),
-                KeyModifiers::ALT,
-            )),
-            search_up: EventDefSet::from(KeyEventDef::new(KeyCode::Up, KeyModifiers::NONE)),
         }
     }
 }
 
 impl ConfigFromFile {
-    /// Load the config from a string.
     pub fn load_from(content: &str) -> anyhow::Result<Self> {
         toml::from_str(content).map_err(Into::into)
     }
@@ -287,149 +240,113 @@ impl Config {
         if let Some(val) = config.word_break_chars {
             self.word_break_chars = val;
         }
-        if let Some(val) = config.move_to_tail {
+    }
+}
+
+#[derive(Clone, Serialize, Deserialize, Builder)]
+#[builder(derive(Serialize, Deserialize))]
+#[builder(name = "KeybindsFromFile")]
+#[serde(deny_unknown_fields)]
+pub struct Keybinds {
+    pub move_to_tail: EventDefSet,
+    pub backward: EventDefSet,
+    pub forward: EventDefSet,
+    pub completion: EventDefSet,
+    pub move_to_head: EventDefSet,
+    pub move_to_previous_nearest: EventDefSet,
+    pub move_to_next_nearest: EventDefSet,
+    pub erase: EventDefSet,
+    pub erase_all: EventDefSet,
+    pub erase_to_previous_nearest: EventDefSet,
+    pub erase_to_next_nearest: EventDefSet,
+    pub search_up: EventDefSet,
+}
+
+impl Default for Keybinds {
+    fn default() -> Self {
+        Self {
+            move_to_tail: EventDefSet::from(KeyEventDef::new(
+                KeyCode::Char('e'),
+                KeyModifiers::CONTROL,
+            )),
+            move_to_head: EventDefSet::from(KeyEventDef::new(
+                KeyCode::Char('a'),
+                KeyModifiers::CONTROL,
+            )),
+            backward: EventDefSet::from(KeyEventDef::new(KeyCode::Left, KeyModifiers::NONE)),
+            forward: EventDefSet::from(KeyEventDef::new(KeyCode::Right, KeyModifiers::NONE)),
+            completion: EventDefSet::from(KeyEventDef::new(KeyCode::Tab, KeyModifiers::NONE)),
+            move_to_next_nearest: EventDefSet::from(KeyEventDef::new(
+                KeyCode::Char('f'),
+                KeyModifiers::ALT,
+            )),
+            move_to_previous_nearest: EventDefSet::from(KeyEventDef::new(
+                KeyCode::Char('b'),
+                KeyModifiers::ALT,
+            )),
+            erase: EventDefSet::from(KeyEventDef::new(KeyCode::Backspace, KeyModifiers::NONE)),
+            erase_all: EventDefSet::from(KeyEventDef::new(
+                KeyCode::Char('u'),
+                KeyModifiers::CONTROL,
+            )),
+            erase_to_previous_nearest: EventDefSet::from(KeyEventDef::new(
+                KeyCode::Char('w'),
+                KeyModifiers::CONTROL,
+            )),
+            erase_to_next_nearest: EventDefSet::from(KeyEventDef::new(
+                KeyCode::Char('d'),
+                KeyModifiers::ALT,
+            )),
+            search_up: EventDefSet::from(KeyEventDef::new(KeyCode::Up, KeyModifiers::NONE)),
+        }
+    }
+}
+
+impl KeybindsFromFile {
+    /// Load the config from a string.
+    pub fn load_from(content: &str) -> anyhow::Result<Self> {
+        toml::from_str(content).map_err(Into::into)
+    }
+}
+
+impl Keybinds {
+    pub fn patch_with(&mut self, keybinds: KeybindsFromFile) {
+        // TODO: This is awful verbose. Can we do better?
+        if let Some(val) = keybinds.move_to_tail {
             self.move_to_tail = val;
         }
-        if let Some(val) = config.move_to_head {
+        if let Some(val) = keybinds.move_to_head {
             self.move_to_head = val;
         }
-        if let Some(val) = config.backward {
+        if let Some(val) = keybinds.backward {
             self.backward = val;
         }
-        if let Some(val) = config.forward {
+        if let Some(val) = keybinds.forward {
             self.forward = val;
         }
-        if let Some(val) = config.completion {
+        if let Some(val) = keybinds.completion {
             self.completion = val;
         }
-        if let Some(val) = config.move_to_next_nearest {
+        if let Some(val) = keybinds.move_to_next_nearest {
             self.move_to_next_nearest = val;
         }
-        if let Some(val) = config.move_to_previous_nearest {
+        if let Some(val) = keybinds.move_to_previous_nearest {
             self.move_to_previous_nearest = val;
         }
-        if let Some(val) = config.erase {
+        if let Some(val) = keybinds.erase {
             self.erase = val;
         }
-        if let Some(val) = config.erase_all {
+        if let Some(val) = keybinds.erase_all {
             self.erase_all = val;
         }
-        if let Some(val) = config.erase_to_previous_nearest {
+        if let Some(val) = keybinds.erase_to_previous_nearest {
             self.erase_to_previous_nearest = val;
         }
-        if let Some(val) = config.erase_to_next_nearest {
+        if let Some(val) = keybinds.erase_to_next_nearest {
             self.erase_to_next_nearest = val;
         }
-        if let Some(val) = config.search_up {
+        if let Some(val) = keybinds.search_up {
             self.search_up = val;
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    mod load_from {
-        use super::super::*;
-
-        #[test]
-        fn test() {
-            let toml = r#"
-                search_result_chunk_size = 10
-                query_debounce_duration = "1000ms"
-                resize_debounce_duration = "2s"
-                search_load_chunk_size = 5
-                focus_prefix = "❯ "
-                spin_duration = "500ms"
-
-                [active_item_style]
-                foreground = "green"
-
-                [focus_active_char_style]
-                background = "green"
-                underline = "red"
-                attributes = ["Bold", "Underlined"]
-
-                [move_to_tail]
-                code = { Char = "$" }
-                modifiers = "CONTROL"
-            "#;
-
-            let config = ConfigFromFile::load_from(toml).unwrap();
-
-            assert_eq!(config.search_result_chunk_size, Some(10));
-            assert_eq!(
-                config.query_debounce_duration,
-                Some(Duration::from_millis(1000))
-            );
-            assert_eq!(
-                config.resize_debounce_duration,
-                Some(Duration::from_secs(2))
-            );
-            assert_eq!(config.spin_duration, Some(Duration::from_millis(500)));
-            assert_eq!(config.search_load_chunk_size, Some(5));
-            assert_eq!(
-                config.active_item_style,
-                Some(StyleBuilder::new().fgc(Color::Green).build()),
-            );
-
-            assert_eq!(
-                config.move_to_tail,
-                Some(EventDefSet::from(KeyEventDef::new(
-                    KeyCode::Char('$'),
-                    KeyModifiers::CONTROL
-                )))
-            );
-
-            assert_eq!(config.focus_prefix, Some("❯ ".to_string()));
-
-            assert_eq!(
-                config.focus_active_char_style,
-                Some(
-                    StyleBuilder::new()
-                        .bgc(Color::Green)
-                        .ulc(Color::Red)
-                        .attrs(Attributes::from(Attribute::Bold) | Attribute::Underlined)
-                        .build()
-                ),
-            );
-
-            // Check the part of the config that was not set in the toml
-            assert_eq!(config.backward, None);
-            assert_eq!(config.forward, None);
-            assert_eq!(config.completion, None);
-        }
-
-        #[test]
-        fn test_with_empty() {
-            let toml = "";
-            let config = ConfigFromFile::load_from(toml).unwrap();
-
-            assert_eq!(config.search_result_chunk_size, None);
-            assert_eq!(config.query_debounce_duration, None);
-            assert_eq!(config.resize_debounce_duration, None);
-            assert_eq!(config.spin_duration, None);
-            assert_eq!(config.search_load_chunk_size, None);
-            assert_eq!(config.active_item_style, None);
-            assert_eq!(config.inactive_item_style, None);
-            assert_eq!(config.focus_prefix, None);
-            assert_eq!(config.focus_active_char_style, None);
-            assert_eq!(config.move_to_tail, None);
-            assert_eq!(config.move_to_head, None);
-        }
-    }
-
-    mod patch_with {
-        use super::super::*;
-
-        #[test]
-        fn test() {
-            let mut config = Config::default();
-            let config_from_file = ConfigFromFile {
-                focus_prefix: Some(":)".to_string()),
-                ..Default::default()
-            };
-            config.patch_with(config_from_file);
-            assert_eq!(config.focus_prefix, ":)".to_string());
-        }
-    }
-}

src/config/content_style.rs

@@ -1,7 +1,4 @@
-use crossterm::{
-    event::{KeyCode, KeyEvent, KeyModifiers},
-    style::{Attribute, Attributes, Color, ContentStyle},
-};
+use crossterm::style::{Attribute, Attributes, Color, ContentStyle};
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]

src/editor.rs

@@ -6,7 +6,10 @@ use crossterm::{
 };
 use promkit::{pane::Pane, style::StyleBuilder, text, text_editor, PaneFactory};
 
-use crate::search::IncrementalSearcher;
+use crate::{
+    config::{event::Matcher, Keybinds},
+    search::IncrementalSearcher,
+};
 
 pub struct Editor {
     keybind: Keybind,
@@ -29,21 +32,6 @@ pub struct EditorTheme {
     pub inactive_char_style: ContentStyle,
 }
 
-pub struct Keybinds {
-    pub move_to_tail: KeyEvent,
-    pub backward: KeyEvent,
-    pub forward: KeyEvent,
-    pub completion: KeyEvent,
-    pub move_to_head: KeyEvent,
-    pub move_to_previous_nearest: KeyEvent,
-    pub move_to_next_nearest: KeyEvent,
-    pub erase: KeyEvent,
-    pub erase_all: KeyEvent,
-    pub erase_to_previous_nearest: KeyEvent,
-    pub erase_to_next_nearest: KeyEvent,
-    pub search_up: KeyEvent,
-}
-
 impl Editor {
     pub fn new(
         state: text_editor::State,
@@ -124,7 +112,7 @@ pub async fn edit<'a>(event: &'a Event, editor: &'a mut Editor) -> anyhow::Resul
     editor.guide.text = Default::default();
 
     match event {
-        key if key == &Event::Key(editor.keybinds.completion) => {
+        key if editor.keybinds.completion.matches(key) => {
             let prefix = editor.state.texteditor.text_without_cursor().to_string();
             match editor.searcher.start_search(&prefix) {
                 Ok(result) => match result.head_item {
@@ -158,52 +146,49 @@ pub async fn edit<'a>(event: &'a Event, editor: &'a mut Editor) -> anyhow::Resul
         }
 
         // Move cursor.
-        key if key == &Event::Key(editor.keybinds.backward) => {
+        key if editor.keybinds.backward.matches(key) => {
             editor.state.texteditor.backward();
         }
-        key if key == &Event::Key(editor.keybinds.forward) => {
+        key if editor.keybinds.forward.matches(key) => {
             editor.state.texteditor.forward();
         }
-        key if key == &Event::Key(editor.keybinds.move_to_head) => {
+        key if editor.keybinds.move_to_head.matches(key) => {
             editor.state.texteditor.move_to_head();
         }
-
-        key if key == &Event::Key(editor.keybinds.move_to_tail) => {
+        key if editor.keybinds.move_to_tail.matches(key) => {
             editor.state.texteditor.move_to_tail();
         }
 
         // Move cursor to the nearest character.
-        key if key == &Event::Key(editor.keybinds.move_to_previous_nearest) => {
+        key if editor.keybinds.move_to_previous_nearest.matches(key) => {
             editor
                 .state
                 .texteditor
                 .move_to_previous_nearest(&editor.state.word_break_chars);
         }
-
-        key if key == &Event::Key(editor.keybinds.move_to_next_nearest) => {
+        key if editor.keybinds.move_to_next_nearest.matches(key) => {
             editor
                 .state
                 .texteditor
                 .move_to_next_nearest(&editor.state.word_break_chars);
         }
 
         // Erase char(s).
-        key if key == &Event::Key(editor.keybinds.erase) => {
+        key if editor.keybinds.erase.matches(key) => {
             editor.state.texteditor.erase();
         }
-        key if key == &Event::Key(editor.keybinds.erase_all) => {
+        key if editor.keybinds.erase_all.matches(key) => {
             editor.state.texteditor.erase_all();
         }
 
         // Erase to the nearest character.
-        key if key == &Event::Key(editor.keybinds.erase_to_previous_nearest) => {
+        key if editor.keybinds.erase_to_previous_nearest.matches(key) => {
             editor
                 .state
                 .texteditor
                 .erase_to_previous_nearest(&editor.state.word_break_chars);
         }
-
-        key if key == &Event::Key(editor.keybinds.erase_to_next_nearest) => {
+        key if editor.keybinds.erase_to_next_nearest.matches(key) => {
             editor
                 .state
                 .texteditor
@@ -254,7 +239,7 @@ pub async fn search<'a>(event: &'a Event, editor: &'a mut Editor) -> anyhow::Res
                 .replace(&editor.searcher.get_current_item());
         }
 
-        key if key == &Event::Key(editor.keybinds.search_up) => {
+        key if editor.keybinds.search_up.matches(key) => {
             editor.searcher.up();
             editor
                 .state

src/main.rs

@@ -6,7 +6,7 @@ use std::{
 
 use anyhow::anyhow;
 use clap::Parser;
-use config::{Config, ConfigFromFile};
+use config::{Config, ConfigFromFile, Keybinds, KeybindsFromFile};
 use crossterm::style::Attribute;
 use promkit::{
     jsonz::format::RowFormatter,
@@ -217,12 +217,14 @@ async fn main() -> anyhow::Result<()> {
     let args = Args::parse();
     let input = parse_input(&args)?;
 
-    let mut config = Config::default();
+    let (mut config, mut keybinds) = (Config::default(), Keybinds::default());
     if let Ok(config_file) = determine_config_file(args.config_file, &config) {
         // Note that the configuration file absolutely exists.
         let content = std::fs::read_to_string(&config_file)?;
-        let loaded = ConfigFromFile::load_from(&content)?;
-        config.patch_with(loaded);
+        let config_from_file = ConfigFromFile::load_from(&content)?;
+        let keybinds_from_file = KeybindsFromFile::load_from(&content)?;
+        config.patch_with(config_from_file);
+        keybinds.patch_with(keybinds_from_file);
     }
 
     let config::Config {
@@ -233,26 +235,14 @@ async fn main() -> anyhow::Result<()> {
         active_item_style,
         defocus_prefix,
         focus_prefix,
-        move_to_tail,
         word_break_chars,
-        backward,
-        forward,
         defocus_prefix_style,
         defocus_active_char_style,
         defocus_inactive_char_style,
         focus_prefix_style,
         focus_active_char_style,
         focus_inactive_char_style,
         inactive_item_style,
-        completion,
-        move_to_head,
-        move_to_next_nearest,
-        move_to_previous_nearest,
-        erase,
-        erase_all,
-        erase_to_previous_nearest,
-        erase_to_next_nearest,
-        search_up,
         spin_duration,
         prefix_style,
         active_char_style,
@@ -323,27 +313,12 @@ async fn main() -> anyhow::Result<()> {
 
     let loading_suggestions_task = searcher.spawn_load_task(provider, item, search_load_chunk_size);
 
-    let editor_keybinds = editor::Keybinds {
-        move_to_tail,
-        backward,
-        forward,
-        completion,
-        move_to_head,
-        move_to_previous_nearest,
-        move_to_next_nearest,
-        erase,
-        erase_all,
-        erase_to_previous_nearest,
-        erase_to_next_nearest,
-        search_up,
-    };
-
     let editor = Editor::new(
         text_editor_state,
         searcher,
         editor_focus_theme,
         editor_defocus_theme,
-        editor_keybinds,
+        keybinds,
     );
 
     prompt::run(