mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-17 06:11:21 +01:00
komorebi-for-kde/komorebic/src/{main.rs,hotkeys.rs,applications.json} and tests/{check,cli,hotkeys}.rs
move to komorebic/src/linux/{mod.rs,hotkeys.rs,applications.json} and komorebic/tests/linux_*.rs
(#![cfg(target_os = "linux")]). The only edits are paths: include_str! and the tests' fixture and
repository-root paths point into komorebi-for-kde/ (docs, komorebi-hotkeys, schema files),
komorebi/tests/asc.rs reads the moved applications.json. The old package komorebic-linux stays and
builds from the moved file through a shim (src/main.rs includes ../../../komorebic/src/linux/mod.rs), so
the old name works until the cutover; its tests now run in the unified package. The KDE flake builds and
tests komorebic (unified) instead of komorebic-linux, its source filter takes the unified package's
manifest, build.rs, main.rs, src/linux and tests/linux_*; the Windows source filter leaves the Linux
and macOS files out. Comments and docs that name komorebic/src/main.rs or komorebic/tests/*.rs
(check.rs, ARCHITECTURE.md, scripts/compare-gen.py, the VM check suite) were not touched: they would
change the KDE derivations for text only.
Gates run: KDE cargo test -p komorebi-linux -p komorebic -p komorebic-linux -p komorebi-client-linux
-p komorebi-hotkeys --no-fail-fast: 888 passed, 0 failed (the moved komorebic tests included); Windows
clippy -D warnings PASS; macOS fake-CC check PASS; fast-check nix evaluation PASS; CLI docs oracle for
kde now generated by the unified komorebic: 166 pages, 0 diff, and its --help first line and --version
equal the old package's. Not run: nix builds (the KDE derivations changed), VM suites. Note: cargo
build/test of both komorebic and komorebic-linux in one command writes the same binary name twice
(use one of them).
749 lines
25 KiB
Rust
749 lines
25 KiB
Rust
//! The key binding subcommands: `export-kde-shortcuts` and `hotkeys`.
|
|
//!
|
|
//! `export-kde-shortcuts` and `hotkeys compile` are front ends over [`komorebi_hotkeys`]: they read
|
|
//! a key binding file ([`komorebi_hotkeys::parse`]), sort its bindings into KDE shortcut files and
|
|
//! the engine's ([`komorebi_hotkeys::plan::plan`]), print what the crate has to say about the file,
|
|
//! and write the shortcut files ([`komorebi_hotkeys::kde::write`]). `export-kde-shortcuts` does
|
|
//! this for an skhdrc, as static shortcuts only; `hotkeys compile` for a file of any of the three
|
|
//! formats, in any [`PlanMode`].
|
|
//!
|
|
//! The other `hotkeys` subcommands are about the engine of the daemon. `hotkeys state` prints the
|
|
//! keys komorebi has registered with KDE ([`komorebi::kwin::hotkeys::registered`]) and what the
|
|
//! engine is doing (the daemon's answer to `HotkeysState`), `hotkeys reload` has the daemon read
|
|
//! its key binding file again (`ReloadHotkeys`), and `hotkeys release` unregisters every key
|
|
//! komorebi registered ([`komorebi::kwin::hotkeys::release`]), with or without a daemon.
|
|
|
|
use super::HOME_DIR;
|
|
use clap::Parser;
|
|
use clap::Subcommand;
|
|
use clap::ValueEnum;
|
|
use color_eyre::eyre;
|
|
use komorebi_client::SocketMessage;
|
|
use komorebi_client::check::Finding;
|
|
use komorebi_hotkeys::Diagnostic;
|
|
use komorebi_hotkeys::Format;
|
|
use komorebi_hotkeys::ParseOptions;
|
|
use komorebi_hotkeys::Parsed;
|
|
use komorebi_hotkeys::Severity;
|
|
use komorebi_hotkeys::kde;
|
|
use komorebi_hotkeys::plan::Plan;
|
|
use komorebi_hotkeys::plan::PlanMode;
|
|
use komorebi_hotkeys::plan::PlanOptions;
|
|
use std::path::Path;
|
|
use std::path::PathBuf;
|
|
use std::process::Command;
|
|
use std::process::Stdio;
|
|
|
|
#[derive(Parser)]
|
|
pub struct ExportKdeShortcuts {
|
|
/// The skhdrc to translate [default: skhdrc in the komorebi config directory]
|
|
#[clap(short, long)]
|
|
skhdrc: Option<PathBuf>,
|
|
/// Where to write the shortcut files [default: $XDG_DATA_HOME/kglobalaccel]
|
|
#[clap(short, long)]
|
|
output: Option<PathBuf>,
|
|
/// Activate shortcuts that are new straight away, instead of at the next login
|
|
#[clap(long)]
|
|
reload: bool,
|
|
/// Show the shortcuts that would be written without writing anything
|
|
#[clap(long)]
|
|
dry_run: bool,
|
|
}
|
|
|
|
#[derive(Parser)]
|
|
pub struct Hotkeys {
|
|
#[clap(subcommand)]
|
|
command: HotkeysCommand,
|
|
}
|
|
|
|
#[derive(Subcommand)]
|
|
enum HotkeysCommand {
|
|
/// Plan the bindings of a key binding file, and write those that are static shortcuts as KDE
|
|
/// shortcut files
|
|
Compile(Compile),
|
|
/// Show the keys komorebi has registered with KDE, and what the engine of the daemon is doing
|
|
State,
|
|
/// Have the daemon read its key binding file again
|
|
Reload,
|
|
/// Unregister every key komorebi has registered with KDE, whether a daemon runs or not
|
|
Release,
|
|
}
|
|
|
|
#[derive(Parser)]
|
|
struct Compile {
|
|
/// The key binding file [default: the first of skhdrc, whkdrc and sxhkdrc in the komorebi
|
|
/// config directory]
|
|
file: Option<PathBuf>,
|
|
/// The format of the file [default: from the end of its name: skhdrc, whkdrc or sxhkdrc]
|
|
#[clap(short, long, value_enum)]
|
|
format: Option<KeyFormat>,
|
|
/// Which bindings are static shortcuts: none (engine), every binding a shortcut file can
|
|
/// express (auto), or only those, leaving the others out (static)
|
|
#[clap(short, long, value_enum, default_value_t = PlanMode::default().into())]
|
|
mode: KeyPlanMode,
|
|
/// Where to write the shortcut files [default: $XDG_DATA_HOME/kglobalaccel]
|
|
#[clap(short, long)]
|
|
output: Option<PathBuf>,
|
|
/// Write nothing, and fail, when a diagnostic is a warning or an error: something in the
|
|
/// file is not realized the way its own hotkey daemon realizes it
|
|
#[clap(long)]
|
|
strict: bool,
|
|
/// Activate shortcuts that are new straight away, instead of at the next login
|
|
#[clap(long)]
|
|
reload: bool,
|
|
/// Show the shortcuts that would be written without writing anything
|
|
#[clap(long)]
|
|
dry_run: bool,
|
|
}
|
|
|
|
/// [`Format`], for the command line
|
|
#[derive(Clone, Copy, ValueEnum)]
|
|
enum KeyFormat {
|
|
Skhd,
|
|
Whkd,
|
|
Sxhkd,
|
|
}
|
|
|
|
impl From<KeyFormat> for Format {
|
|
fn from(format: KeyFormat) -> Self {
|
|
match format {
|
|
KeyFormat::Skhd => Format::Skhd,
|
|
KeyFormat::Whkd => Format::Whkd,
|
|
KeyFormat::Sxhkd => Format::Sxhkd,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// [`PlanMode`], for the command line
|
|
#[derive(Clone, Copy, ValueEnum)]
|
|
enum KeyPlanMode {
|
|
Auto,
|
|
Engine,
|
|
Static,
|
|
}
|
|
|
|
impl From<PlanMode> for KeyPlanMode {
|
|
fn from(mode: PlanMode) -> Self {
|
|
match mode {
|
|
PlanMode::Auto => KeyPlanMode::Auto,
|
|
PlanMode::Engine => KeyPlanMode::Engine,
|
|
PlanMode::Static => KeyPlanMode::Static,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<KeyPlanMode> for PlanMode {
|
|
fn from(mode: KeyPlanMode) -> Self {
|
|
match mode {
|
|
KeyPlanMode::Auto => PlanMode::Auto,
|
|
KeyPlanMode::Engine => PlanMode::Engine,
|
|
KeyPlanMode::Static => PlanMode::Static,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// What to export, and how
|
|
struct Export {
|
|
file: PathBuf,
|
|
format: Format,
|
|
mode: PlanMode,
|
|
output: Option<PathBuf>,
|
|
strict: bool,
|
|
reload: bool,
|
|
dry_run: bool,
|
|
}
|
|
|
|
/// `komorebic export-kde-shortcuts`: the bindings of an skhdrc that can be KDE shortcut files
|
|
pub fn export_kde_shortcuts(args: ExportKdeShortcuts) -> eyre::Result<()> {
|
|
export(Export {
|
|
file: args.skhdrc.unwrap_or_else(|| HOME_DIR.join("skhdrc")),
|
|
format: Format::Skhd,
|
|
mode: PlanMode::Static,
|
|
output: args.output,
|
|
strict: false,
|
|
reload: args.reload,
|
|
dry_run: args.dry_run,
|
|
})
|
|
}
|
|
|
|
/// `komorebic hotkeys`
|
|
pub fn hotkeys(args: Hotkeys) -> eyre::Result<()> {
|
|
match args.command {
|
|
HotkeysCommand::Compile(args) => {
|
|
let file = match args.file {
|
|
Some(file) => file,
|
|
None => find_file(&HOME_DIR)?,
|
|
};
|
|
let format = match args.format {
|
|
Some(format) => format.into(),
|
|
None => format_of(&file)?,
|
|
};
|
|
export(Export {
|
|
file,
|
|
format,
|
|
mode: args.mode.into(),
|
|
output: args.output,
|
|
strict: args.strict,
|
|
reload: args.reload,
|
|
dry_run: args.dry_run,
|
|
})
|
|
}
|
|
HotkeysCommand::State => {
|
|
let registered = komorebi::kwin::hotkeys::registered().map_err(|error| {
|
|
eyre::Report::msg(format!("could not ask KDE for the keys: {error}"))
|
|
})?;
|
|
// no daemon: no engine
|
|
let engine = komorebi_client::send_query(&SocketMessage::HotkeysState)
|
|
.ok()
|
|
.and_then(|answer| serde_json::from_str(&answer).ok())
|
|
.unwrap_or(serde_json::Value::Null);
|
|
let state = serde_json::json!({ "registered": registered, "engine": engine });
|
|
println!("{}", serde_json::to_string_pretty(&state)?);
|
|
Ok(())
|
|
}
|
|
HotkeysCommand::Reload => {
|
|
komorebi_client::send_message(&SocketMessage::ReloadHotkeys)?;
|
|
Ok(())
|
|
}
|
|
HotkeysCommand::Release => {
|
|
let released = komorebi::kwin::hotkeys::release().map_err(|error| {
|
|
eyre::Report::msg(format!("could not release the keys: {error}"))
|
|
})?;
|
|
if released.is_empty() {
|
|
println!("komorebi had no key registered");
|
|
} else {
|
|
println!("released {} keys: {}", released.len(), released.join(", "));
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
}
|
|
|
|
const FORMATS: [Format; 3] = [Format::Skhd, Format::Whkd, Format::Sxhkd];
|
|
|
|
/// The first key binding file of the three formats in `dir`, and its format
|
|
fn find(dir: &Path) -> Option<(PathBuf, Format)> {
|
|
FORMATS
|
|
.into_iter()
|
|
.map(|format| (dir.join(format.file_name()), format))
|
|
.find(|(path, _)| path.is_file())
|
|
}
|
|
|
|
/// The first key binding file of the three formats in `dir`
|
|
fn find_file(dir: &Path) -> eyre::Result<PathBuf> {
|
|
find(dir).map(|(path, _)| path).ok_or_else(|| {
|
|
eyre::Report::msg(format!(
|
|
"there is no skhdrc, whkdrc or sxhkdrc in {}: name the file to read",
|
|
dir.display()
|
|
))
|
|
})
|
|
}
|
|
|
|
/// The format a file's name ends with
|
|
fn format_of(file: &Path) -> eyre::Result<Format> {
|
|
let name = file
|
|
.file_name()
|
|
.and_then(|n| n.to_str())
|
|
.unwrap_or_default();
|
|
FORMATS
|
|
.into_iter()
|
|
.find(|format| name.ends_with(format.file_name()))
|
|
.ok_or_else(|| {
|
|
eyre::Report::msg(format!(
|
|
"{} does not end with skhdrc, whkdrc or sxhkdrc: give its --format",
|
|
file.display()
|
|
))
|
|
})
|
|
}
|
|
|
|
/// Where the shortcut files go when no directory is given: `kglobalaccel` in the data directory
|
|
fn shortcut_dir() -> Option<PathBuf> {
|
|
dirs::data_dir().map(|dir| dir.join("kglobalaccel"))
|
|
}
|
|
|
|
/// What reading and planning a file have to say about it, in the order of the file
|
|
fn diagnostics<'a>(parsed: &'a Parsed, plan: &'a Plan) -> Vec<&'a Diagnostic> {
|
|
let mut diagnostics: Vec<&Diagnostic> =
|
|
parsed.diagnostics.iter().chain(&plan.diagnostics).collect();
|
|
diagnostics.sort_by_key(|diagnostic| diagnostic.span.start);
|
|
diagnostics
|
|
}
|
|
|
|
fn export(export: Export) -> eyre::Result<()> {
|
|
let file = &export.file;
|
|
let text = std::fs::read_to_string(file).map_err(|error| {
|
|
eyre::Report::msg(format!("could not read {}: {error}", file.display()))
|
|
})?;
|
|
let parsed = komorebi_hotkeys::parse(export.format, &text, &ParseOptions::default());
|
|
let plan = komorebi_hotkeys::plan::plan(&parsed.keymap, &PlanOptions { mode: export.mode });
|
|
|
|
let diagnostics = diagnostics(&parsed, &plan);
|
|
for diagnostic in &diagnostics {
|
|
eprintln!("{}: {diagnostic}", file.display());
|
|
}
|
|
if export.strict
|
|
&& diagnostics
|
|
.iter()
|
|
.any(|diagnostic| diagnostic.severity >= Severity::Warning)
|
|
{
|
|
eyre::bail!(
|
|
"{} is not realized as it says (the warnings and errors above), and --strict is set",
|
|
file.display()
|
|
);
|
|
}
|
|
|
|
for shortcut in &plan.static_files {
|
|
println!("{:<24} {}", shortcut.combo.to_string(), shortcut.command);
|
|
}
|
|
let engine: usize = plan.engine.modes.iter().map(|m| m.bindings.len()).sum();
|
|
let files = kde::desktop_files(&plan.static_files);
|
|
let output = export
|
|
.output
|
|
.unwrap_or_else(|| shortcut_dir().expect("there is no data directory"));
|
|
|
|
if export.dry_run {
|
|
let diff = kde::diff(&output, &files)?;
|
|
println!(
|
|
"{} shortcuts would be written to {} ({} new, {} changed, {} removed), {} bindings need the engine",
|
|
files.len(),
|
|
output.display(),
|
|
diff.added.len(),
|
|
diff.changed.len(),
|
|
diff.removed.len(),
|
|
engine
|
|
);
|
|
return Ok(());
|
|
}
|
|
|
|
let written = kde::write(&output, &files)?;
|
|
println!(
|
|
"wrote {} shortcuts to {} ({} new, {} changed, {} removed), {} bindings need the engine",
|
|
files.len(),
|
|
output.display(),
|
|
written.added.len(),
|
|
written.changed.len(),
|
|
written.removed.len(),
|
|
engine
|
|
);
|
|
|
|
// KWin 6.8 runs the global shortcut daemon itself and reads these files when it starts. A
|
|
// shortcut it has not met can be handed over now; one it already runs keeps what it loaded
|
|
// until the next login.
|
|
if export.reload {
|
|
for name in written.added.iter().chain(&written.unchanged) {
|
|
let registered = Command::new("busctl")
|
|
.args([
|
|
"--user",
|
|
"call",
|
|
"org.kde.kglobalaccel",
|
|
"/kglobalaccel",
|
|
"org.kde.KGlobalAccel",
|
|
"doRegister",
|
|
"as",
|
|
"4",
|
|
name,
|
|
"_launch",
|
|
"",
|
|
"",
|
|
])
|
|
.stdout(Stdio::null())
|
|
.status()
|
|
.is_ok_and(|status| status.success());
|
|
if !registered {
|
|
eyre::bail!("could not register {name} with KWin: is this a Plasma session?");
|
|
}
|
|
}
|
|
println!(
|
|
"{} shortcuts are active now",
|
|
written.added.len() + written.unchanged.len()
|
|
);
|
|
if !(written.changed.is_empty() && written.removed.is_empty()) {
|
|
println!(
|
|
"{} changed and {} removed ones take effect at your next login",
|
|
written.changed.len(),
|
|
written.removed.len()
|
|
);
|
|
}
|
|
} else if !files.is_empty() || !written.removed.is_empty() {
|
|
println!("they take effect at your next login; --reload activates new ones straight away");
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// `n` and the noun, in the singular when there is one
|
|
fn count(n: usize, singular: &str, plural: &str) -> String {
|
|
format!("{n} {}", if n == 1 { singular } else { plural })
|
|
}
|
|
|
|
/// The first five diagnostics of a kind, one to a line, for the hint of a finding
|
|
fn lines(diagnostics: &[&Diagnostic], severity: Severity) -> (usize, String) {
|
|
let of_kind: Vec<String> = diagnostics
|
|
.iter()
|
|
.filter(|diagnostic| diagnostic.severity == severity)
|
|
.map(|diagnostic| diagnostic.to_string())
|
|
.collect();
|
|
(
|
|
of_kind.len(),
|
|
of_kind.into_iter().take(5).collect::<Vec<_>>().join("\n"),
|
|
)
|
|
}
|
|
|
|
/// The key bindings, for `komorebic check`: the file `hotkeys compile` would read, what reading
|
|
/// and planning it have to say, and whether the shortcut files there are the ones it would write
|
|
/// for it.
|
|
pub fn check(home: &Path) -> Vec<Finding> {
|
|
check_in(home, shortcut_dir().as_deref(), PlanMode::default())
|
|
}
|
|
|
|
/// [`check`], for the key binding file in `home`, planned in `mode`, against the shortcut files in
|
|
/// `shortcuts`
|
|
fn check_in(home: &Path, shortcuts: Option<&Path>, mode: PlanMode) -> Vec<Finding> {
|
|
let Some((file, format)) = find(home) else {
|
|
return vec![
|
|
Finding::note(format!(
|
|
"there is no skhdrc, whkdrc or sxhkdrc in {}",
|
|
home.display()
|
|
))
|
|
.hint(
|
|
"key bindings are KDE global shortcuts: they come from a key binding file through `komorebic hotkeys compile`, or are set up in System Settings",
|
|
),
|
|
];
|
|
};
|
|
let text = match std::fs::read_to_string(&file) {
|
|
Ok(text) => text,
|
|
Err(error) => {
|
|
return vec![Finding::warning(format!(
|
|
"could not read {}: {error}",
|
|
file.display()
|
|
))];
|
|
}
|
|
};
|
|
|
|
let parsed = komorebi_hotkeys::parse(format, &text, &ParseOptions::default());
|
|
let plan = komorebi_hotkeys::plan::plan(&parsed.keymap, &PlanOptions { mode });
|
|
let diagnostics = diagnostics(&parsed, &plan);
|
|
|
|
let bindings: usize = parsed.keymap.modes.iter().map(|m| m.bindings.len()).sum();
|
|
let engine: usize = plan.engine.modes.iter().map(|m| m.bindings.len()).sum();
|
|
let mut findings = vec![Finding::ok(format!(
|
|
"{} has {}: {} as shortcut files, {} in the engine",
|
|
file.display(),
|
|
count(bindings, "key binding", "key bindings"),
|
|
plan.static_files.len(),
|
|
engine
|
|
))];
|
|
|
|
let (errors, shown) = lines(&diagnostics, Severity::Error);
|
|
if errors > 0 {
|
|
findings.push(
|
|
Finding::warning(format!(
|
|
"{} of it cannot be read and left out",
|
|
count(errors, "line", "lines")
|
|
))
|
|
.hint(shown),
|
|
);
|
|
}
|
|
let (warnings, shown) = lines(&diagnostics, Severity::Warning);
|
|
if warnings > 0 {
|
|
findings.push(
|
|
Finding::note(format!(
|
|
"{} not realized as {} would",
|
|
count(warnings, "binding is", "bindings are"),
|
|
format.file_name().trim_end_matches("rc")
|
|
))
|
|
.hint(shown),
|
|
);
|
|
}
|
|
|
|
let files = kde::desktop_files(&plan.static_files);
|
|
match shortcuts.map(|dir| kde::diff(dir, &files)) {
|
|
Some(Ok(diff)) if diff.added.is_empty() && diff.changed.is_empty() && diff.removed.is_empty() => {
|
|
findings.push(Finding::ok(if files.is_empty() {
|
|
"no shortcut files are needed, and komorebi has written none"
|
|
} else {
|
|
"the shortcut files are the ones `komorebic hotkeys compile` writes"
|
|
}));
|
|
}
|
|
Some(Ok(diff)) => findings.push(
|
|
Finding::warning(format!(
|
|
"the shortcut files are not the ones `komorebic hotkeys compile` would write: {} to add, {} to change, {} to remove",
|
|
diff.added.len(),
|
|
diff.changed.len(),
|
|
diff.removed.len()
|
|
))
|
|
.hint("`komorebic hotkeys compile --reload`"),
|
|
),
|
|
Some(Err(error)) => findings.push(Finding::warning(format!(
|
|
"could not look at the shortcut files: {error}"
|
|
))),
|
|
None => {}
|
|
}
|
|
|
|
findings
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use komorebi_client::check::Level;
|
|
|
|
/// A directory of its own, removed when it goes out of scope
|
|
struct Scratch(PathBuf);
|
|
|
|
impl Scratch {
|
|
fn new() -> Self {
|
|
static NEXT: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
|
|
let dir = std::env::temp_dir().join(format!(
|
|
"komorebic-hotkeys-unit-{}-{}",
|
|
std::process::id(),
|
|
NEXT.fetch_add(1, std::sync::atomic::Ordering::SeqCst)
|
|
));
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
Self(dir)
|
|
}
|
|
|
|
fn file(&self, name: &str, text: &str) -> &Self {
|
|
std::fs::write(self.0.join(name), text).unwrap();
|
|
self
|
|
}
|
|
|
|
fn shortcuts(&self) -> PathBuf {
|
|
self.0.join("shortcuts")
|
|
}
|
|
}
|
|
|
|
impl Drop for Scratch {
|
|
fn drop(&mut self) {
|
|
let _ = std::fs::remove_dir_all(&self.0);
|
|
}
|
|
}
|
|
|
|
const SKHDRC: &str = "alt - h : komorebic focus left\nalt - l : komorebic focus right\n";
|
|
|
|
/// The level and message of each finding
|
|
fn said(findings: &[Finding]) -> Vec<(Level, String)> {
|
|
findings
|
|
.iter()
|
|
.map(|finding| (finding.level, finding.message.clone()))
|
|
.collect()
|
|
}
|
|
|
|
#[test]
|
|
fn without_a_key_binding_file_there_is_a_note_that_says_where_they_come_from() {
|
|
let home = Scratch::new();
|
|
|
|
let findings = check_in(&home.0, Some(&home.shortcuts()), PlanMode::Auto);
|
|
|
|
assert_eq!(findings.len(), 1);
|
|
assert_eq!(findings[0].level, Level::Note);
|
|
assert!(
|
|
findings[0]
|
|
.message
|
|
.starts_with("there is no skhdrc, whkdrc or sxhkdrc in")
|
|
);
|
|
assert!(
|
|
findings[0]
|
|
.hint
|
|
.as_deref()
|
|
.is_some_and(|hint| hint.contains("komorebic hotkeys compile"))
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_first_file_of_the_three_formats_is_the_one_that_is_read() {
|
|
let home = Scratch::new();
|
|
home.file("sxhkdrc", "super + h\n komorebic focus left\n")
|
|
.file(
|
|
"whkdrc",
|
|
"alt + h : komorebic focus left\nalt + l : komorebic focus right\n",
|
|
);
|
|
|
|
let findings = check_in(&home.0, None, PlanMode::Engine);
|
|
|
|
assert_eq!(findings[0].level, Level::Ok);
|
|
assert!(
|
|
findings[0]
|
|
.message
|
|
.ends_with("whkdrc has 2 key bindings: 0 as shortcut files, 2 in the engine"),
|
|
"{}",
|
|
findings[0].message
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_bindings_are_counted_by_where_the_plan_puts_them() {
|
|
let home = Scratch::new();
|
|
home.file(
|
|
"sxhkdrc",
|
|
"super + h\n komorebic focus left\nsuper + l\n komorebic focus right\nsuper + w ; h\n komorebic move left\n",
|
|
);
|
|
|
|
let auto = check_in(&home.0, None, PlanMode::Auto);
|
|
let engine = check_in(&home.0, None, PlanMode::Engine);
|
|
|
|
assert!(
|
|
auto[0]
|
|
.message
|
|
.ends_with("has 3 key bindings: 2 as shortcut files, 1 in the engine"),
|
|
"{}",
|
|
auto[0].message
|
|
);
|
|
assert!(
|
|
engine[0]
|
|
.message
|
|
.ends_with("has 3 key bindings: 0 as shortcut files, 3 in the engine"),
|
|
"{}",
|
|
engine[0].message
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn one_binding_is_not_plural() {
|
|
let home = Scratch::new();
|
|
home.file("skhdrc", "alt - h : komorebic focus left\n");
|
|
|
|
let findings = check_in(&home.0, None, PlanMode::Auto);
|
|
|
|
assert!(
|
|
findings[0]
|
|
.message
|
|
.ends_with("has 1 key binding: 1 as shortcut files, 0 in the engine"),
|
|
"{}",
|
|
findings[0].message
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn shortcut_files_that_are_the_ones_of_the_plan_are_ok() {
|
|
let home = Scratch::new();
|
|
home.file("skhdrc", SKHDRC);
|
|
let parsed = komorebi_hotkeys::parse(Format::Skhd, SKHDRC, &ParseOptions::default());
|
|
let plan = komorebi_hotkeys::plan::plan(
|
|
&parsed.keymap,
|
|
&PlanOptions {
|
|
mode: PlanMode::Auto,
|
|
},
|
|
);
|
|
kde::write(&home.shortcuts(), &kde::desktop_files(&plan.static_files)).unwrap();
|
|
|
|
let findings = check_in(&home.0, Some(&home.shortcuts()), PlanMode::Auto);
|
|
|
|
assert_eq!(
|
|
said(&findings)[1],
|
|
(
|
|
Level::Ok,
|
|
"the shortcut files are the ones `komorebic hotkeys compile` writes".to_string()
|
|
)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn shortcut_files_that_are_not_the_ones_of_the_plan_are_a_warning_that_says_how_many() {
|
|
let home = Scratch::new();
|
|
home.file("skhdrc", SKHDRC);
|
|
let old = "alt - h : komorebic focus left\nalt - x : komorebic focus down\n";
|
|
let parsed = komorebi_hotkeys::parse(Format::Skhd, old, &ParseOptions::default());
|
|
let plan = komorebi_hotkeys::plan::plan(
|
|
&parsed.keymap,
|
|
&PlanOptions {
|
|
mode: PlanMode::Auto,
|
|
},
|
|
);
|
|
kde::write(&home.shortcuts(), &kde::desktop_files(&plan.static_files)).unwrap();
|
|
|
|
let findings = check_in(&home.0, Some(&home.shortcuts()), PlanMode::Auto);
|
|
|
|
assert_eq!(findings[1].level, Level::Warning);
|
|
assert_eq!(
|
|
findings[1].message,
|
|
"the shortcut files are not the ones `komorebic hotkeys compile` would write: 1 to add, 0 to change, 1 to remove"
|
|
);
|
|
assert_eq!(
|
|
findings[1].hint.as_deref(),
|
|
Some("`komorebic hotkeys compile --reload`")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_file_that_needs_no_shortcut_files_and_a_directory_without_any_agree() {
|
|
let home = Scratch::new();
|
|
home.file("skhdrc", SKHDRC);
|
|
|
|
let findings = check_in(&home.0, Some(&home.shortcuts()), PlanMode::Engine);
|
|
|
|
assert_eq!(
|
|
said(&findings)[1],
|
|
(
|
|
Level::Ok,
|
|
"no shortcut files are needed, and komorebi has written none".to_string()
|
|
)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_line_that_cannot_be_read_is_a_warning_that_shows_the_line() {
|
|
let home = Scratch::new();
|
|
home.file(
|
|
"skhdrc",
|
|
"alt - h : komorebic focus left\nalt - nosuchkey : komorebic focus up\n",
|
|
);
|
|
|
|
let findings = check_in(&home.0, None, PlanMode::Auto);
|
|
|
|
assert_eq!(findings[1].level, Level::Warning);
|
|
assert_eq!(
|
|
findings[1].message,
|
|
"1 line of it cannot be read and left out"
|
|
);
|
|
assert!(
|
|
findings[1]
|
|
.hint
|
|
.as_deref()
|
|
.is_some_and(|hint| hint.starts_with("line 2: error: ")),
|
|
"{:?}",
|
|
findings[1].hint
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_binding_that_is_not_realized_as_its_own_daemon_would_is_a_note() {
|
|
let home = Scratch::new();
|
|
home.file("skhdrc", "lalt - j : komorebic focus down\n");
|
|
|
|
let findings = check_in(&home.0, None, PlanMode::Auto);
|
|
|
|
assert_eq!(findings[1].level, Level::Note);
|
|
assert_eq!(
|
|
findings[1].message,
|
|
"1 binding is not realized as skhd would"
|
|
);
|
|
assert!(
|
|
findings[1]
|
|
.hint
|
|
.as_deref()
|
|
.is_some_and(|hint| hint.starts_with("line 1: warning: ")),
|
|
"{:?}",
|
|
findings[1].hint
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn a_hint_shows_five_lines_at_most() {
|
|
let home = Scratch::new();
|
|
let text: String = (0..8)
|
|
.map(|n| format!("lalt - {} : x\n", (b'a' + n) as char))
|
|
.collect();
|
|
home.file("skhdrc", &text);
|
|
|
|
let findings = check_in(&home.0, None, PlanMode::Auto);
|
|
|
|
assert_eq!(
|
|
findings[1].message,
|
|
"8 bindings are not realized as skhd would"
|
|
);
|
|
assert_eq!(findings[1].hint.as_deref().unwrap().lines().count(), 5);
|
|
}
|
|
}
|