feat(whkd): initial commit

Author: LGUG2Z

.gitignore

@@ -0,0 +1,2 @@
+/target
+.idea

Cargo.lock

@@ -0,0 +1,14 @@
+[package]
+name = "whkd"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+chumsky = "0.8"
+color-eyre = "0.6"
+dirs = "4"
+lazy_static = "1"
+parking_lot = "0.12"
+windows-hotkeys = "0.1.1"

Cargo.toml

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Jade Iqbal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE

@@ -0,0 +1,25 @@
+# whkd
+
+_whkd_ is a simple hotkey daemon for Windows that reacts to input events by executing commands.
+
+Its configuration file (`~/.config/whkdrc`) is a series of bindings which define the associations between the input events and the commands.
+
+The format of the configuration file (and this project itself) is heavily inspired by `skhd` and `sxhkd`.
+
+## Example
+
+```
+.shell pwsh # can be one of cmd | pwsh | powershell
+
+# reload configuration
+alt + o : taskkill /f /im whkd.exe && Start-Process whkd -WindowStyle hidden
+
+# app shortcuts
+alt + f : if ($wshell.AppActivate('Firefox') -eq $False) { start firefox }
+
+# focus windows with komorebi
+alt + h : komorebic focus left
+alt + j : komorebic focus down
+alt + k : komorebic focus up
+alt + l : komorebic focus right
+```

README.md

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "stable"

rust-toolchain.toml

@@ -0,0 +1 @@
+imports_granularity = "Item"

rustfmt.toml

@@ -0,0 +1,127 @@
+#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
+#![allow(clippy::missing_errors_doc, clippy::redundant_pub_crate)]
+
+use crate::parser::HotkeyBinding;
+use crate::whkdrc::Shell;
+use crate::whkdrc::Whkdrc;
+use color_eyre::eyre::eyre;
+use color_eyre::eyre::Result;
+use lazy_static::lazy_static;
+use parking_lot::Mutex;
+use std::io::Write;
+use std::process::ChildStdin;
+use std::process::Command;
+use std::process::Stdio;
+use windows_hotkeys::error::HkError;
+use windows_hotkeys::keys::ModKey;
+use windows_hotkeys::keys::VKey;
+use windows_hotkeys::HotkeyManager;
+
+mod parser;
+mod whkdrc;
+
+lazy_static! {
+    static ref WHKDRC: Whkdrc = {
+        let mut home = dirs::home_dir().expect("no home directory found");
+        home.push(".config");
+        home.push("whkdrc");
+
+        Whkdrc::load(&home).expect("could not load whkdrc")
+    };
+    static ref SESSION_STDIN: Mutex<Option<ChildStdin>> = Mutex::new(None);
+}
+
+#[derive(Debug)]
+pub struct HkmData {
+    pub mod_keys: Vec<ModKey>,
+    pub vkey: VKey,
+    pub command: String,
+}
+
+impl HkmData {
+    pub fn register(&self, hkm: &mut HotkeyManager<()>) -> Result<()> {
+        let cmd = self.command.clone();
+
+        hkm.register(self.vkey, self.mod_keys.as_slice(), move || {
+            if let Some(session_stdin) = SESSION_STDIN.lock().as_mut() {
+                if matches!(WHKDRC.shell, Shell::Pwsh | Shell::Powershell) {
+                    println!("{cmd}");
+                }
+
+                writeln!(session_stdin, "{cmd}").expect("failed to execute command");
+            }
+        })?;
+
+        Ok(())
+    }
+}
+
+impl TryFrom<&HotkeyBinding> for HkmData {
+    type Error = HkError;
+
+    fn try_from(value: &HotkeyBinding) -> Result<Self, Self::Error> {
+        let (trigger, mods) = value.keys.split_last().unwrap();
+        let mut mod_keys = vec![];
+        let vkey = VKey::from_keyname(trigger)?;
+        for m in mods {
+            mod_keys.push(ModKey::from_keyname(m)?);
+        }
+
+        Ok(Self {
+            mod_keys,
+            vkey,
+            command: value.command.clone(),
+        })
+    }
+}
+
+fn main() -> Result<()> {
+    color_eyre::install()?;
+
+    let shell_binary = WHKDRC.shell.to_string();
+
+    match WHKDRC.shell {
+        Shell::Powershell | Shell::Pwsh => {
+            let mut process = Command::new(&shell_binary)
+                .stdin(Stdio::piped())
+                .args(["-Command", "-"])
+                .spawn()?;
+
+            let mut stdin = process
+                .stdin
+                .take()
+                .ok_or_else(|| eyre!("could not take stdin from powershell session"))?;
+
+            writeln!(stdin, "$wshell = New-Object -ComObject wscript.shell")?;
+
+            let mut session_stdin = SESSION_STDIN.lock();
+            *session_stdin = Option::from(stdin);
+        }
+        Shell::Cmd => {
+            let mut process = Command::new(&shell_binary)
+                .stdin(Stdio::piped())
+                .args(["-"])
+                .spawn()?;
+
+            let mut stdin = process
+                .stdin
+                .take()
+                .ok_or_else(|| eyre!("could not take stdin from cmd session"))?;
+
+            writeln!(stdin, "prompt $S")?;
+
+            let mut session_stdin = SESSION_STDIN.lock();
+            *session_stdin = Option::from(stdin);
+        }
+    }
+
+    let mut hkm = HotkeyManager::new();
+
+    for binding in &WHKDRC.bindings {
+        HkmData::try_from(binding)?.register(&mut hkm)?;
+    }
+
+    hkm.event_loop();
+
+    Ok(())
+}

src/main.rs

@@ -0,0 +1,106 @@
+use crate::whkdrc::Shell;
+use crate::whkdrc::Whkdrc;
+use chumsky::prelude::*;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HotkeyBinding {
+    pub keys: Vec<String>,
+    pub command: String,
+}
+
+#[must_use]
+pub fn parser() -> impl Parser<char, Whkdrc, Error = Simple<char>> {
+    let comment = just::<_, _, Simple<char>>("#")
+        .then(take_until(text::newline()))
+        .padded()
+        .ignored();
+
+    let shell = just(".shell")
+        .padded()
+        .ignore_then(choice((just("pwsh"), just("powershell"), just("cmd"))))
+        .repeated()
+        .exactly(1)
+        .collect::<String>()
+        .map(Shell::from);
+
+    let hotkeys = choice((text::ident(), text::int(10)))
+        .padded()
+        .separated_by(just("+"))
+        .at_least(2)
+        .collect::<Vec<String>>();
+
+    let delimiter = just(":").padded();
+
+    let command = take_until(choice((comment, text::newline())))
+        .padded()
+        .map(|c| c.0)
+        .collect::<String>();
+
+    let binding = hotkeys.then_ignore(delimiter).then(command);
+
+    shell
+        .then(
+            binding
+                .map(|(keys, command)| HotkeyBinding { keys, command })
+                .padded()
+                .padded_by(comment.repeated())
+                .repeated()
+                .at_least(1),
+        )
+        .map(|(shell, bindings)| Whkdrc { shell, bindings })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse() {
+        let src = r#"
+.shell cmd
+
+# leading newlines are fine
+# line comments should parse and be ignored
+alt + h     : komorebic focus left # so should comments at the end of a line
+alt + j     : komorebic focus down
+alt + k     : komorebic focus up
+alt + l     : komorebic focus right
+
+# so should empty lines
+alt + 1 : komorebic focus-workspace 0 # digits are fine in the hotkeys section
+
+# trailing newlines are fine
+
+
+"#;
+
+        let output = parser().parse(src);
+        let expected = Whkdrc {
+            shell: Shell::Cmd,
+            bindings: vec![
+                HotkeyBinding {
+                    keys: vec![String::from("alt"), String::from("h")],
+                    command: String::from("komorebic focus left"),
+                },
+                HotkeyBinding {
+                    keys: vec![String::from("alt"), String::from("j")],
+                    command: String::from("komorebic focus down"),
+                },
+                HotkeyBinding {
+                    keys: vec![String::from("alt"), String::from("k")],
+                    command: String::from("komorebic focus up"),
+                },
+                HotkeyBinding {
+                    keys: vec![String::from("alt"), String::from("l")],
+                    command: String::from("komorebic focus right"),
+                },
+                HotkeyBinding {
+                    keys: vec![String::from("alt"), String::from("1")],
+                    command: String::from("komorebic focus-workspace 0"),
+                },
+            ],
+        };
+
+        assert_eq!(output.unwrap(), expected);
+    }
+}

src/parser.rs

@@ -0,0 +1,53 @@
+use crate::parser::parser;
+use crate::parser::HotkeyBinding;
+use chumsky::Parser;
+use color_eyre::eyre::eyre;
+use color_eyre::eyre::Result;
+use std::fmt::Display;
+use std::fmt::Formatter;
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Whkdrc {
+    pub shell: Shell,
+    pub bindings: Vec<HotkeyBinding>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Shell {
+    Cmd,
+    Powershell,
+    Pwsh,
+}
+
+#[allow(clippy::fallible_impl_from)]
+impl From<String> for Shell {
+    fn from(value: String) -> Self {
+        match value.as_str() {
+            "pwsh" => Self::Pwsh,
+            "powershell" => Self::Powershell,
+            "cmd" => Self::Cmd,
+            _ => panic!("unsupported shell"),
+        }
+    }
+}
+
+impl Display for Shell {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Cmd => write!(f, "cmd"),
+            Self::Powershell => write!(f, "powershell"),
+            Self::Pwsh => write!(f, "pwsh"),
+        }
+    }
+}
+
+impl Whkdrc {
+    pub fn load(path: &PathBuf) -> Result<Self> {
+        let contents = std::fs::read_to_string(path)?;
+
+        parser()
+            .parse(contents)
+            .map_err(|error| eyre!("could not parse whkdrc: {:?}", error))
+    }
+}