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/src/config/command.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-use super::keybind::Keybind;
+use crate::config::keybind::Keybind;
 
 #[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
 pub enum Command {

lefthk/src/config/keybind.rs

@@ -1,13 +1,10 @@
 use crate::errors::{LeftError, Result};
-use lefthk_core::config::command as command_mod;
-use lefthk_core::config::Command as core_command;
-use lefthk_core::config::Keybind as core_keybind;
-use serde::Deserialize;
-use serde::Serialize;
+use lefthk_core::config::{
+    command as command_mod, Command as core_command, Keybind as core_keybind,
+};
+use serde::{Deserialize, Serialize};
 
-use super::{command::Command, key::Key};
-
-use std::convert::TryFrom;
+use crate::config::{command::Command, key::Key};
 
 macro_rules! get_key {
     ($expr:expr $(,)?) => {
@@ -32,75 +29,74 @@ pub type Keybinds = Vec<Keybind>;
 #[derive(Debug, PartialEq, Clone, Eq, Serialize, Deserialize)]
 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<(Box<dyn 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();
+pub(crate) fn try_from(kb: Keybind, default_modifier: &[String]) -> Result<Vec<core_keybind>> {
+    let command_key_pairs: Vec<(Box<dyn 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) {
+                    Ok(keybinds) => Some::<Vec<lefthk_core::config::Keybind>>(keybinds),
+                    Err(err) => {
+                        tracing::error!("Invalid key binding: {}\n{:?}", err, kb);
+                        None
+                    }
+                })
+                .flatten()
+                .collect();
 
-                vec![(Box::new(command_mod::Chord::new(children)), key)]
-            }
-            Command::Chord(_) => return Err(LeftError::ChildrenNotFound),
-            Command::Execute(value) if !value.is_empty() => {
-                let keys = get_key!(kb.key);
-                vec![(Box::new(command_mod::Execute::new(&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)| {
-                        (
-                            Box::new(command_mod::Execute::new(&v)) as Box<dyn core_command>,
-                            keys[i].clone(),
-                        )
-                    })
-                    .collect()
-            }
-            Command::Executes(_) => return Err(LeftError::ValuesNotFound),
-            Command::ExitChord => {
-                let keys = get_key!(kb.key);
-                vec![(Box::new(command_mod::ExitChord::new()), keys)]
-            }
-            Command::Reload => {
-                let keys = get_key!(kb.key);
-                vec![(Box::new(command_mod::Reload::new()), keys)]
-            }
-            Command::Kill => {
-                let keys = get_key!(kb.key);
-                vec![(Box::new(command_mod::Kill::new()), keys)]
+            vec![(Box::new(command_mod::Chord::new(children)), key)]
+        }
+        Command::Chord(_) => return Err(LeftError::ChildrenNotFound),
+        Command::Execute(value) if !value.is_empty() => {
+            let keys = get_key!(kb.key);
+            vec![((Box::new(command_mod::Execute::new(&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.normalize(),
-                modifier: kb.modifier.clone(),
-                key: k.clone(),
-            })
-            .collect();
-        Ok(keybinds)
-    }
+            values
+                .iter()
+                .enumerate()
+                .map(|(i, v)| {
+                    (
+                        Box::new(command_mod::Execute::new(&v)) as Box<dyn core_command>,
+                        keys[i].clone(),
+                    )
+                })
+                .collect()
+        }
+        Command::Executes(_) => return Err(LeftError::ValuesNotFound),
+        Command::ExitChord => {
+            let keys = get_key!(kb.key);
+            vec![((Box::new(command_mod::ExitChord::new())), keys)]
+        }
+        Command::Reload => {
+            let keys = get_key!(kb.key);
+            vec![((Box::new(command_mod::Reload::new())), keys)]
+        }
+        Command::Kill => {
+            let keys = get_key!(kb.key);
+            vec![((Box::new(command_mod::Kill::new())), keys)]
+        }
+    };
+    let keybinds = command_key_pairs
+        .iter()
+        .map(|(c, k)| core_keybind {
+            command: c.normalize(),
+            modifier: kb
+                .modifier
+                .clone()
+                .unwrap_or_else(|| default_modifier.to_vec()),
+            key: k.clone(),
+        })
+        .collect();
+    Ok(keybinds)
 }

lefthk/src/config/mod.rs

@@ -5,7 +5,7 @@ pub mod keybind;
 use crate::errors::{LeftError, Result};
 
 use serde::{Deserialize, Serialize};
-use std::{convert::TryFrom, fs, path::Path};
+use std::{fs, path::Path};
 use xdg::BaseDirectories;
 
 use self::{
@@ -15,35 +15,35 @@ use self::{
 
 #[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize)]
 pub struct Config {
+    pub(crate) default_modifier: Vec<String>,
     keybinds: Keybinds,
 }
 
 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 keybind::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()
     }
 }
 
-/// # Errors
-///
-/// Thes will error when no config file is found, most propably as system or
-/// user error for provideng a wrong path
-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 TryFrom<String> for Config {
+    type Error = LeftError;
+    /// # Errors
+    ///
+    /// Thes will error when no config file is found, most propably as system or
+    /// user error for provideng a wrong path
+    fn try_from(contents: String) -> Result<Self> {
         let mut config: Config = ron::from_str(&contents)?;
         let global_exit_chord = config
             .keybinds
@@ -57,7 +57,20 @@ pub fn load() -> Result<Config> {
             .collect();
         propagate_exit_chord(chords, &global_exit_chord);
 
-        return Ok(config);
+        Ok(config)
+    }
+}
+
+/// # Errors
+///
+/// This errors, when no Config is found at the path
+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::try_from(contents)?;
     }
     Err(LeftError::NoConfigFound)
 }

lefthk/src/main.rs

@@ -1,12 +1,15 @@
 use crate::errors::LeftError;
 use clap::{App, Arg};
-use lefthk_core::config::{command, Command};
-use lefthk_core::ipc::Pipe;
-use lefthk_core::worker::Status;
-use lefthk_core::{config::Config, worker::Worker};
-use std::fs;
-use std::io::Write;
-use std::sync::atomic::{AtomicBool, Ordering};
+use lefthk_core::{
+    config::{command, Command, Config},
+    ipc::Pipe,
+    worker::{Status, Worker},
+};
+use std::{
+    fs,
+    io::Write,
+    sync::atomic::{AtomicBool, Ordering},
+};
 use xdg::BaseDirectories;
 
 use tracing_subscriber::{filter::EnvFilter, filter::LevelFilter, fmt, layer::SubscriberExt};