Default Modifier

README.md

@@ -6,16 +6,16 @@ LeftHK - A hotkey daemon written in Rust
 The configuration file should be created in ~/.config/lefthk/ and called config.ron. If the configuration file is not created the program will exit.
 Example config:
 ```ron
+#![enable(implicit_some)]
 Config(
+    default_modifier: ["Mod4", "Shift"],
     keybinds: [
         Keybind(
             command: Execute("st -e htop"),
-            modifier: ["Mod4", "Shift"],
             key: Key("x"),
         ),
         Keybind(
             command: Executes(["st -e htop", "st -e bpytop"]),
-            modifier: ["Mod4", "Shift"],
             key: Keys(["x", "m"]),
         ),
         Keybind(

lefthk-core/src/child.rs

@@ -32,7 +32,7 @@ impl Children {
         let (guard, _task_guard) = oneshot::channel();
         let task_notify = Arc::new(Notify::new());
         let notify = task_notify.clone();
-        let mut signals = Signals::new(&[signal::SIGCHLD]).expect("Couldn't setup signals.");
+        let mut signals = Signals::new([signal::SIGCHLD]).expect("Couldn't setup signals.");
         tokio::task::spawn_blocking(move || loop {
             if guard.is_closed() {
                 return;

lefthk-core/src/worker.rs

@@ -141,7 +141,7 @@ impl Worker {
     pub fn exec(&mut self, command: &str) -> Error {
         let child = Command::new("sh")
             .arg("-c")
-            .arg(&command)
+            .arg(command)
             .stdin(Stdio::null())
             .stdout(Stdio::null())
             .spawn()?;

lefthk/src/config.rs

@@ -2,7 +2,7 @@ use crate::errors::{LeftError, Result};
 use lefthk_core::config::Command as core_command;
 use lefthk_core::config::Keybind as core_keybind;
 use serde::{Deserialize, Serialize};
-use std::{convert::TryFrom, fs, path::Path};
+use std::{fs, path::Path};
 use xdg::BaseDirectories;
 
 #[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone)]
@@ -42,101 +42,100 @@ macro_rules! get_keys {
 #[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Eq)]
 pub struct Keybind {
     pub command: Command,
-    pub modifier: Vec<String>,
+    pub modifier: Option<Vec<String>>,
     pub key: Key,
 }
 
-impl TryFrom<Keybind> for Vec<core_keybind> {
-    type Error = LeftError;
-
-    fn try_from(kb: Keybind) -> Result<Self> {
-        let command_key_pairs: Vec<(core_command, String)> = match kb.command {
-            Command::Chord(children) if !children.is_empty() => {
-                let key = get_key!(kb.key);
-                let children = children
-                    .iter()
-                    .filter_map(|kb| match TryFrom::try_from(kb.clone()) {
-                        Ok(keybinds) => Some::<Vec<lefthk_core::config::Keybind>>(keybinds),
-                        Err(err) => {
-                            tracing::error!("Invalid key binding: {}\n{:?}", err, kb);
-                            None
-                        }
-                    })
-                    .flatten()
-                    .collect();
+fn try_from(kb: Keybind, default_modifier: Vec<String>) -> Result<Vec<core_keybind>> {
+    let command_key_pairs: Vec<(core_command, String)> = match kb.command {
+        Command::Chord(children) if !children.is_empty() => {
+            let key = get_key!(kb.key);
+            let children = children
+                .iter()
+                .filter_map(|kb| match try_from(kb.clone(), default_modifier.clone()) {
+                    Ok(keybinds) => Some::<Vec<lefthk_core::config::Keybind>>(keybinds),
+                    Err(err) => {
+                        tracing::error!("Invalid key binding: {}\n{:?}", err, kb);
+                        None
+                    }
+                })
+                .flatten()
+                .collect();
 
-                vec![(core_command::Chord(children), key)]
-            }
-            Command::Chord(_) => return Err(LeftError::ChildrenNotFound),
-            Command::Execute(value) if !value.is_empty() => {
-                let keys = get_key!(kb.key);
-                vec![(core_command::Execute(value), keys)]
-            }
-            Command::Execute(_) => return Err(LeftError::ValueNotFound),
-            Command::Executes(values) if !values.is_empty() => {
-                let keys = get_keys!(kb.key);
-                if keys.len() != values.len() {
-                    return Err(LeftError::NumberOfKeysDiffersFromValues);
-                }
-                values
-                    .iter()
-                    .enumerate()
-                    .map(|(i, v)| (core_command::Execute(v.to_owned()), keys[i].clone()))
-                    .collect()
-            }
-            Command::Executes(_) => return Err(LeftError::ValuesNotFound),
-            Command::ExitChord => {
-                let keys = get_key!(kb.key);
-                vec![(core_command::ExitChord, keys)]
-            }
-            Command::Reload => {
-                let keys = get_key!(kb.key);
-                vec![(core_command::Reload, keys)]
-            }
-            Command::Kill => {
-                let keys = get_key!(kb.key);
-                vec![(core_command::Kill, keys)]
+            vec![(core_command::Chord(children), key)]
+        }
+        Command::Chord(_) => return Err(LeftError::ChildrenNotFound),
+        Command::Execute(value) if !value.is_empty() => {
+            let keys = get_key!(kb.key);
+            vec![(core_command::Execute(value), keys)]
+        }
+        Command::Execute(_) => return Err(LeftError::ValueNotFound),
+        Command::Executes(values) if !values.is_empty() => {
+            let keys = get_keys!(kb.key);
+            if keys.len() != values.len() {
+                return Err(LeftError::NumberOfKeysDiffersFromValues);
             }
-        };
-        let keybinds = command_key_pairs
-            .iter()
-            .map(|(c, k)| core_keybind {
-                command: c.clone(),
-                modifier: kb.modifier.clone(),
-                key: k.to_owned(),
-            })
-            .collect();
-        Ok(keybinds)
-    }
+            values
+                .iter()
+                .enumerate()
+                .map(|(i, v)| (core_command::Execute(v.to_owned()), keys[i].clone()))
+                .collect()
+        }
+        Command::Executes(_) => return Err(LeftError::ValuesNotFound),
+        Command::ExitChord => {
+            let keys = get_key!(kb.key);
+            vec![(core_command::ExitChord, keys)]
+        }
+        Command::Reload => {
+            let keys = get_key!(kb.key);
+            vec![(core_command::Reload, keys)]
+        }
+        Command::Kill => {
+            let keys = get_key!(kb.key);
+            vec![(core_command::Kill, keys)]
+        }
+    };
+    let keybinds = command_key_pairs
+        .iter()
+        .map(|(c, k)| core_keybind {
+            command: c.clone(),
+            modifier: kb
+                .modifier
+                .clone()
+                .unwrap_or_else(|| default_modifier.clone()),
+            key: k.to_owned(),
+        })
+        .collect();
+    Ok(keybinds)
 }
 
 #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]
 pub struct Config {
-    keybinds: Vec<Keybind>,
+    pub default_modifier: Vec<String>,
+    pub keybinds: Vec<Keybind>,
 }
 
 impl lefthk_core::config::Config for Config {
     fn mapped_bindings(&self) -> Vec<lefthk_core::config::Keybind> {
         self.keybinds
             .iter()
-            .filter_map(|kb| match TryFrom::try_from(kb.clone()) {
-                Ok(keybinds) => Some::<Vec<lefthk_core::config::Keybind>>(keybinds),
-                Err(err) => {
-                    tracing::error!("Invalid key binding: {}\n{:?}", err, kb);
-                    None
-                }
-            })
+            .filter_map(
+                |kb| match try_from(kb.clone(), self.default_modifier.clone()) {
+                    Ok(keybinds) => Some::<Vec<lefthk_core::config::Keybind>>(keybinds),
+                    Err(err) => {
+                        tracing::error!("Invalid key binding: {}\n{:?}", err, kb);
+                        None
+                    }
+                },
+            )
             .flatten()
             .collect()
     }
 }
 
-pub fn load() -> Result<Config> {
-    let path = BaseDirectories::with_prefix(lefthk_core::LEFTHK_DIR_NAME)?;
-    fs::create_dir_all(&path.get_config_home())?;
-    let file_name = path.place_config_file("config.ron")?;
-    if Path::new(&file_name).exists() {
-        let contents = fs::read_to_string(file_name)?;
+impl Config {
+    pub fn from_string(contents: String) -> Result<Self> {
+        println!("{contents}");
         let mut config: Config = ron::from_str(&contents)?;
         let global_exit_chord = config
             .keybinds
@@ -150,7 +149,17 @@ pub fn load() -> Result<Config> {
             .collect();
         propagate_exit_chord(chords, global_exit_chord);
 
-        return Ok(config);
+        Ok(config)
+    }
+}
+
+pub fn load() -> Result<Config> {
+    let path = BaseDirectories::with_prefix(lefthk_core::LEFTHK_DIR_NAME)?;
+    fs::create_dir_all(&path.get_config_home())?;
+    let file_name = path.place_config_file("config.ron")?;
+    if Path::new(&file_name).exists() {
+        let contents = fs::read_to_string(file_name)?;
+        Config::from_string(contents)?;
     }
     Err(LeftError::NoConfigFound)
 }