mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-17 22:33:12 +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).
346 lines
10 KiB
Rust
346 lines
10 KiB
Rust
#![cfg(target_os = "linux")]
|
|
//! `export-kde-shortcuts` and `hotkeys compile` as a person runs them: the shortcut files they
|
|
//! write for a key binding file, what they print, and when they refuse.
|
|
|
|
use std::path::Path;
|
|
use std::path::PathBuf;
|
|
use std::process::Command;
|
|
use std::process::Output;
|
|
use std::sync::atomic::AtomicU32;
|
|
use std::sync::atomic::Ordering;
|
|
|
|
/// A directory for one test: a komorebi config directory in `config`, and shortcut files in
|
|
/// `shortcuts`
|
|
struct Scratch(PathBuf);
|
|
|
|
impl Scratch {
|
|
fn new() -> Self {
|
|
static NEXT: AtomicU32 = AtomicU32::new(0);
|
|
let dir = std::env::temp_dir().join(format!(
|
|
"komorebic-hotkeys-{}-{}",
|
|
std::process::id(),
|
|
NEXT.fetch_add(1, Ordering::SeqCst)
|
|
));
|
|
let _ = std::fs::remove_dir_all(&dir);
|
|
std::fs::create_dir_all(dir.join("config")).unwrap();
|
|
Self(dir)
|
|
}
|
|
|
|
fn config(&self) -> PathBuf {
|
|
self.0.join("config")
|
|
}
|
|
|
|
fn shortcuts(&self) -> PathBuf {
|
|
self.0.join("shortcuts")
|
|
}
|
|
|
|
/// Writes `text` to the config directory as `name`, and returns its path
|
|
fn file(&self, name: &str, text: &str) -> PathBuf {
|
|
let path = self.config().join(name);
|
|
std::fs::write(&path, text).unwrap();
|
|
path
|
|
}
|
|
|
|
fn komorebic(&self, args: &[&str]) -> Output {
|
|
Command::new(env!("CARGO_BIN_EXE_komorebic"))
|
|
.args(args)
|
|
.env("KOMOREBI_CONFIG_HOME", self.config())
|
|
.output()
|
|
.unwrap()
|
|
}
|
|
|
|
/// The names of the files in the shortcut directory, sorted
|
|
fn written(&self) -> Vec<String> {
|
|
let Ok(entries) = std::fs::read_dir(self.shortcuts()) else {
|
|
return Vec::new();
|
|
};
|
|
let mut names: Vec<String> = entries
|
|
.map(|entry| entry.unwrap().file_name().into_string().unwrap())
|
|
.collect();
|
|
names.sort();
|
|
names
|
|
}
|
|
}
|
|
|
|
impl Drop for Scratch {
|
|
fn drop(&mut self) {
|
|
let _ = std::fs::remove_dir_all(&self.0);
|
|
}
|
|
}
|
|
|
|
fn stdout(output: &Output) -> String {
|
|
String::from_utf8_lossy(&output.stdout).into_owned()
|
|
}
|
|
|
|
fn stderr(output: &Output) -> String {
|
|
String::from_utf8_lossy(&output.stderr).into_owned()
|
|
}
|
|
|
|
fn fixture(name: &str) -> PathBuf {
|
|
Path::new(env!("CARGO_MANIFEST_DIR"))
|
|
.join("../komorebi-for-kde/komorebi-hotkeys/tests/fixtures")
|
|
.join(name)
|
|
}
|
|
|
|
const SKHDRC: &str = "\
|
|
alt - h : komorebic focus left
|
|
alt - l : komorebic focus right
|
|
lalt - j : komorebic focus down
|
|
:: resize
|
|
alt - r ; resize
|
|
resize < h : komorebic resize-axis horizontal decrease
|
|
";
|
|
|
|
#[test]
|
|
fn export_kde_shortcuts_writes_a_file_for_each_binding_a_shortcut_can_be() {
|
|
let scratch = Scratch::new();
|
|
scratch.file("skhdrc", SKHDRC);
|
|
|
|
let output = scratch.komorebic(&[
|
|
"export-kde-shortcuts",
|
|
"--output",
|
|
scratch.shortcuts().to_str().unwrap(),
|
|
]);
|
|
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert_eq!(
|
|
scratch.written(),
|
|
[
|
|
"komorebi-focus-down.desktop",
|
|
"komorebi-focus-left.desktop",
|
|
"komorebi-focus-right.desktop",
|
|
]
|
|
);
|
|
let left =
|
|
std::fs::read_to_string(scratch.shortcuts().join("komorebi-focus-left.desktop")).unwrap();
|
|
assert!(left.contains("\nX-KDE-Shortcuts=Alt+H\n"), "{left}");
|
|
assert!(left.contains("\nExec=komorebic focus left\n"), "{left}");
|
|
assert!(
|
|
stdout(&output).starts_with("Alt+H komorebic focus left\n"),
|
|
"{output:?}"
|
|
);
|
|
assert!(
|
|
stdout(&output).contains("wrote 3 shortcuts to "),
|
|
"{output:?}"
|
|
);
|
|
// the modes are left out, and lalt is either Alt: the diagnostics say so, with the file
|
|
let diagnostics = stderr(&output);
|
|
assert!(
|
|
diagnostics.contains("skhdrc: line 3: warning: "),
|
|
"{diagnostics}"
|
|
);
|
|
assert!(
|
|
diagnostics.contains("skhdrc: line 5: warning: "),
|
|
"{diagnostics}"
|
|
);
|
|
assert!(diagnostics.contains("is left out"), "{diagnostics}");
|
|
}
|
|
|
|
#[test]
|
|
fn a_dry_run_writes_nothing_and_says_what_a_write_would_change() {
|
|
let scratch = Scratch::new();
|
|
let skhdrc = scratch.file("my-bindings", SKHDRC);
|
|
let shortcuts = scratch.shortcuts();
|
|
std::fs::create_dir_all(&shortcuts).unwrap();
|
|
std::fs::write(shortcuts.join("mine.desktop"), "[Desktop Entry]\n").unwrap();
|
|
|
|
let output = scratch.komorebic(&[
|
|
"export-kde-shortcuts",
|
|
"--skhdrc",
|
|
skhdrc.to_str().unwrap(),
|
|
"--output",
|
|
shortcuts.to_str().unwrap(),
|
|
"--dry-run",
|
|
]);
|
|
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert_eq!(scratch.written(), ["mine.desktop"]);
|
|
assert!(
|
|
stdout(&output).contains("3 shortcuts would be written to "),
|
|
"{output:?}"
|
|
);
|
|
assert!(
|
|
stdout(&output).contains("(3 new, 0 changed, 0 removed), 0 bindings need the engine"),
|
|
"{output:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn compile_writes_the_same_shortcut_files_from_each_format() {
|
|
let written = |file: &str| {
|
|
let scratch = Scratch::new();
|
|
let output = scratch.komorebic(&[
|
|
"hotkeys",
|
|
"compile",
|
|
"--mode",
|
|
"auto",
|
|
fixture(file).to_str().unwrap(),
|
|
"--output",
|
|
scratch.shortcuts().to_str().unwrap(),
|
|
]);
|
|
assert!(output.status.success(), "{output:?}");
|
|
scratch.written()
|
|
};
|
|
|
|
let skhd = written("sample.skhdrc");
|
|
|
|
assert_eq!(skhd.len(), 50);
|
|
assert_eq!(skhd, written("sample.whkdrc"));
|
|
assert_eq!(skhd, written("sample.sxhkdrc"));
|
|
}
|
|
|
|
#[test]
|
|
fn compile_without_a_file_reads_the_first_file_of_the_config_directory() {
|
|
let scratch = Scratch::new();
|
|
scratch.file("whkdrc", ".shell pwsh\nalt + h : komorebic focus left\n");
|
|
scratch.file("sxhkdrc", "alt + l\n komorebic focus right\n");
|
|
|
|
let output = scratch.komorebic(&[
|
|
"hotkeys",
|
|
"compile",
|
|
"--mode",
|
|
"static",
|
|
"--output",
|
|
scratch.shortcuts().to_str().unwrap(),
|
|
]);
|
|
|
|
assert!(output.status.success(), "{output:?}");
|
|
// skhdrc, whkdrc, sxhkdrc: the whkdrc is the first that exists
|
|
assert_eq!(scratch.written(), ["komorebi-focus-left.desktop"]);
|
|
}
|
|
|
|
#[test]
|
|
fn compile_in_engine_mode_writes_no_shortcut_and_removes_the_ones_it_wrote() {
|
|
let scratch = Scratch::new();
|
|
let skhdrc = scratch.file("skhdrc", SKHDRC);
|
|
let compile = |mode: &str| {
|
|
scratch.komorebic(&[
|
|
"hotkeys",
|
|
"compile",
|
|
"--mode",
|
|
mode,
|
|
skhdrc.to_str().unwrap(),
|
|
"--output",
|
|
scratch.shortcuts().to_str().unwrap(),
|
|
])
|
|
};
|
|
assert!(compile("static").status.success());
|
|
assert_eq!(scratch.written().len(), 3);
|
|
|
|
let output = compile("engine");
|
|
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert!(scratch.written().is_empty());
|
|
assert!(
|
|
stdout(&output).contains("wrote 0 shortcuts to "),
|
|
"{output:?}"
|
|
);
|
|
assert!(
|
|
stdout(&output).contains("(0 new, 0 changed, 3 removed), 5 bindings need the engine"),
|
|
"{output:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn strict_refuses_a_file_with_a_warning_and_writes_nothing() {
|
|
let scratch = Scratch::new();
|
|
let skhdrc = scratch.file("skhdrc", SKHDRC);
|
|
|
|
let output = scratch.komorebic(&[
|
|
"hotkeys",
|
|
"compile",
|
|
"--strict",
|
|
"--mode",
|
|
"auto",
|
|
skhdrc.to_str().unwrap(),
|
|
"--output",
|
|
scratch.shortcuts().to_str().unwrap(),
|
|
]);
|
|
|
|
assert!(!output.status.success(), "{output:?}");
|
|
assert!(scratch.written().is_empty());
|
|
assert!(stderr(&output).contains("--strict is set"), "{output:?}");
|
|
|
|
let clean = scratch.file("clean-skhdrc", "alt - h : komorebic focus left\n");
|
|
let output = scratch.komorebic(&[
|
|
"hotkeys",
|
|
"compile",
|
|
"--strict",
|
|
"--mode",
|
|
"auto",
|
|
clean.to_str().unwrap(),
|
|
"--output",
|
|
scratch.shortcuts().to_str().unwrap(),
|
|
]);
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert_eq!(scratch.written(), ["komorebi-focus-left.desktop"]);
|
|
}
|
|
|
|
#[test]
|
|
fn a_file_whose_name_says_no_format_needs_one() {
|
|
let scratch = Scratch::new();
|
|
let file = scratch.file("bindings.conf", "alt + h\n komorebic focus left\n");
|
|
let shortcuts = scratch.shortcuts();
|
|
let compile = |extra: &[&str]| {
|
|
let mut args = vec!["hotkeys", "compile", "--mode", "static"];
|
|
args.extend_from_slice(extra);
|
|
args.extend([
|
|
file.to_str().unwrap(),
|
|
"--output",
|
|
shortcuts.to_str().unwrap(),
|
|
]);
|
|
scratch.komorebic(&args)
|
|
};
|
|
|
|
let output = compile(&[]);
|
|
assert!(!output.status.success(), "{output:?}");
|
|
assert!(stderr(&output).contains("give its --format"), "{output:?}");
|
|
|
|
let output = compile(&["--format", "sxhkd"]);
|
|
assert!(output.status.success(), "{output:?}");
|
|
assert_eq!(scratch.written(), ["komorebi-focus-left.desktop"]);
|
|
}
|
|
|
|
#[test]
|
|
fn state_and_release_without_a_session_bus_say_that_kde_cannot_be_reached() {
|
|
let scratch = Scratch::new();
|
|
let run = |args: &[&str]| {
|
|
Command::new(env!("CARGO_BIN_EXE_komorebic"))
|
|
.args(args)
|
|
.env(
|
|
"DBUS_SESSION_BUS_ADDRESS",
|
|
"unix:path=/nonexistent/komorebic-test.bus",
|
|
)
|
|
.env("XDG_RUNTIME_DIR", &scratch.0)
|
|
.output()
|
|
.unwrap()
|
|
};
|
|
|
|
let output = run(&["hotkeys", "release"]);
|
|
assert!(!output.status.success(), "{output:?}");
|
|
assert!(
|
|
stderr(&output).contains("could not release the keys"),
|
|
"{output:?}"
|
|
);
|
|
|
|
let output = run(&["hotkeys", "state"]);
|
|
assert!(!output.status.success(), "{output:?}");
|
|
assert!(
|
|
stderr(&output).contains("could not ask KDE for the keys"),
|
|
"{output:?}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn reload_without_a_daemon_fails() {
|
|
let scratch = Scratch::new();
|
|
|
|
let output = Command::new(env!("CARGO_BIN_EXE_komorebic"))
|
|
.args(["hotkeys", "reload"])
|
|
.env("XDG_RUNTIME_DIR", &scratch.0)
|
|
.output()
|
|
.unwrap();
|
|
|
|
assert!(!output.status.success(), "{output:?}");
|
|
}
|