feat(wm): application specific configuration

Rules for particular applications can be kept in files of their own,
applications.json, which komorebi.json names with
app_specific_configuration_path: one path or a list. The ignore, manage and
floating rules of every application in a file are added to the lists the
configuration's own rules go in, so a file can be shared or kept apart from the
settings.

A path with no file behind it is skipped with a warning, since one komorebi.json
is meant to work on every platform and may name a file that only another
platform has; a file that is there and is not an applications.json is an error.
The titleless and tabbed rules of other platforms are read and do nothing.

komorebic/applications.json is a start for Plasma: it floats the calculators,
the screenshot tool, the authentication dialog and System Settings. A test opens
the windows it names.
This commit is contained in:
LGUG2Z committed 2026-10-28 07:20:37 -07:00
1 parent 5eaa613f50
commit ed34286bca
15 files changed
+564 -6

No files matched your search

+3 -1
View File
@@ -199,7 +199,9 @@ applies it again to the windows it has. It also sets what a window that opens
gets (`window_container_behaviour`, `float_override`, `floating_layer_behaviour`,
for a workspace or for all of them) and what focusing does in monocle
(`monocle_focus_behaviour`). A key that komorebi for KDE does not read
is ignored, so one file serves every platform. `workspace-layout-rule` makes a
is ignored, so one file serves every platform. Rules for particular applications
can be in files of their own, which `app_specific_configuration_path` names.
`workspace-layout-rule` makes a
workspace change layout with the number of windows it has, as the file's
`layout_rules` do, and `generate-static-config` prints the settings the daemon
has as a `komorebi.json`.
+12 -1
View File
@@ -669,6 +669,13 @@ first and applies it only when it parsed, so a file that is half written changes
for the window manager that is running what the three steps do for one that starts, and tiles
every monitor again.
`app_specific_configuration_path` names files of rules for particular applications, which
[`StaticConfig`] reads after the rules of its own (`apply_globals`): the `ignore`, `manage` and
`floating` rules of each application in each file are appended to the same lists, once each (a
rule that is in the list already is not added again). A path with no file is skipped with a
warning, since one `komorebi.json` may name a file that only another platform has; a file that is
there and is not an applications.json is an error.
Three kinds of key reach the model. A **setting** of the window manager is a field of it
([`WindowManager::resize_delta`] and the others). A **default** is a process-wide static that a
monitor or a workspace falls back to when it has no value of its own: the paddings, the layout
@@ -686,6 +693,8 @@ goes the other way, for `GenerateStaticConfig`.
| A key komorebi does not read does not stop a configuration from loading | serde: [`StaticConfig`] ignores unknown keys, and a key of another platform is a field nothing reads | `the_keys_that_do_nothing_on_kde_are_accepted_and_ignored`, `fixtures_load_round_trip_and_only_lose_windows_only_keys` | none |
| The keys the parity test ignores are keys `StaticConfig` does not read | test: the ignore lists are compared with the schema of [`StaticConfig`] | `the_lists_name_no_key_that_is_read` | none |
| The example in the docs is the example file, which loads | test | `the_example_in_the_docs_is_the_example_file`, `fixtures_load_round_trip_and_only_lose_windows_only_keys` | none |
| A path to an applications file that is not there is skipped, and one that is there and is broken is an error | framework path: `handle_asc_file` returns early when the path does not exist, and parses the file otherwise | `a_missing_application_specific_configuration_is_skipped_not_fatal`, `an_application_specific_configuration_that_exists_but_is_broken_is_still_an_error`, `a_file_that_is_not_there_is_skipped_and_one_that_is_broken_is_an_error` | none |
| The rules of an applications file and of the configuration add up | framework path: both are appended to the process-wide lists | `the_rules_of_the_configuration_and_of_the_file_add_up`, `every_file_of_a_list_is_read` | none |
| A file that cannot be read changes nothing | framework path: [`StaticConfig::reload`] reads and parses the file before it applies anything | `a_configuration_that_cannot_be_read_changes_nothing`, `the_daemon_follows_the_file_it_is_given_when_the_file_changes` | none |
| The daemon applies a change to its file, written in place or replaced by a rename | framework path: the watcher sends `ReloadStaticConfiguration` to the daemon's own socket | `the_daemon_follows_the_file_it_is_given_when_the_file_changes`, `vm-module` | none: the file has to be the one the daemon was started with |
| A monitor takes the entry its display index preference gives it, else the first nobody has | framework path: [`StaticConfig::postload`] and [`StaticConfig::reload`] choose the entry by serial number id first | `a_monitor_takes_the_configuration_its_display_index_preference_gives_it` | none |
@@ -987,7 +996,9 @@ A window is shown, and ends up on a tile:
with several monitors, [`komorebi/tests/hot_reload.rs`](../../komorebi/tests/hot_reload.rs) the
daemon following a file, and
[`komorebi/tests/config_parity.rs`](../../komorebi/tests/config_parity.rs) the files of other
platforms and the example, which load.
platforms and the example, which load; [`komorebi/tests/asc.rs`](../../komorebi/tests/asc.rs)
the applications files; [`komorebi/src/core/asc.rs`](../../komorebi/src/core/asc.rs) their
format.
- [`komorebi/src/process_event.rs`](../../komorebi/src/process_event.rs): what each event
does, and the thread that handles them.
- [`komorebi/src/process_command.rs`](../../komorebi/src/process_command.rs): the socket, what
+7
View File
@@ -347,3 +347,10 @@ which do not exist here. The watcher is `hotwatch`, whose default is to wait two
editor to settle. An editor either writes a file in place or replaces it with a new one, so the
daemon reloads on a modification and on a removal, and the test that follows a real daemon
through both of them is `the_daemon_follows_the_file_it_is_given_when_the_file_changes`.
## Why is an applications file that is not there skipped, and one that is broken an error?
Because one `komorebi.json` is meant to work on every platform, and the file it points to may be
one that another platform has: a configuration written for macOS names `applications.mac.json`,
which a KDE desktop does not have. The daemon warns and goes on. A file that exists and is not an
applications.json is a mistake in something the user wrote, and is an error.
+10
View File
@@ -12,6 +12,7 @@ different layout. This page has the file as it is:
```json
{
"app_specific_configuration_path": "$HOME/.config/komorebi/applications.json",
"cross_monitor_move_behaviour": "Insert",
"default_workspace_padding": 15,
"default_container_padding": 15,
@@ -67,6 +68,15 @@ with `komorebic start --config`. [Configuration](usage/configuration.md) explain
where the daemon looks. The settings of a monitor with more than one entry in `monitors`, and of
each workspace, are there too.
### Application specific configuration
`app_specific_configuration_path` names a file of rules for the applications that need them, which
the repository has a start of in
[`komorebic/applications.json`](../komorebic/applications.json). Put a copy where the example
says, `~/.config/komorebi/applications.json`; a path with no file behind it is skipped.
[Application specific configuration](usage/application-specific-configuration.md) explains the
format.
### Padding
While you can set the workspace padding (the space between the outer edges of the windows and
+3 -2
View File
@@ -51,8 +51,9 @@ float its windows.
[Workspaces](usage/workspaces.md) explains how each monitor shows one of its workspaces, which
are KWin's virtual desktops, and how to show another or move a window to one.
[Configuration](usage/configuration.md) explains `komorebi.json`, where komorebi looks for it and
how it is reloaded when it changes, and [Example configurations](example-configurations.md) has
one to start from.
how it is reloaded when it changes, [Example configurations](example-configurations.md) has one to
start from, and [Application specific configuration](usage/application-specific-configuration.md)
explains the files of rules for particular applications it can name.
[Subscribing to notifications](usage/subscribing-to-notifications.md) explains how a program
such as a status bar follows what komorebi does. The [CLI reference](cli/start.md) has a page
for every `komorebic` command, generated from its help.
+1
View File
@@ -1,4 +1,5 @@
{
"app_specific_configuration_path": "$HOME/.config/komorebi/applications.json",
"cross_monitor_move_behaviour": "Insert",
"default_workspace_padding": 15,
"default_container_padding": 15,
@@ -0,0 +1,73 @@
# Application specific configuration
Some applications need to be told how to behave under a tiling window manager: a calculator that
should float instead of taking a tile, a launcher that should never be tiled. The
[rules](rules.md) that say so can be put in `komorebi.json`, or in a file of their own,
`applications.json`, that the configuration names. The file can be shared, or kept apart from
the settings, and a list of files can be put together from several sources.
## The file
`applications.json` is an object with one entry for each application. The name of the entry is
only for the reader. Each entry has lists of [rules](rules.md), as `komorebi.json` has them:
```json
{
"KDE Plasma": {
"floating": [
{ "kind": "Class", "id": "org.kde.kcalc", "matching_strategy": "Equals" },
{ "kind": "Class", "id": "org.kde.spectacle", "matching_strategy": "Equals" }
]
},
"Steam": {
"ignore": [{ "kind": "Exe", "id": "steam", "matching_strategy": "Equals" }]
}
}
```
| List | What it does | In `komorebi.json` |
|---|---|---|
| `ignore` | komorebi leaves the windows alone | `ignore_rules` |
| `manage` | komorebi tiles the windows, whatever the ignore rules say | `manage_rules` |
| `floating` | the windows open floating | `floating_applications` |
| `titleless`, `tabbed` | nothing: they work around how another platform exposes windows, and a KWin window is always a window | `titleless_applications`, `tabbed_applications` |
An entry named `$schema` has the address of a schema as its value, as an editor wants it, and
is ignored.
## Naming the file
`app_specific_configuration_path` in `komorebi.json` is the path of one file, or a list of paths:
```json
{
"app_specific_configuration_path": "$HOME/.config/komorebi/applications.json"
}
```
```json
{
"app_specific_configuration_path": [
"$HOME/.config/komorebi/applications.json",
"$HOME/.config/komorebi/mine.json"
]
}
```
Environment variables in a path, such as `$HOME`, are replaced. The files are read when
`komorebi.json` is: when the daemon starts, and again when the configuration changes. Their rules
are added to the ones the daemon has, after the rules of `komorebi.json` itself, which
[Configuration](configuration.md#rules) explains.
A path with no file behind it is skipped, and the daemon logs a warning: one `komorebi.json` can
serve every platform, even if it names a file that only another platform has. A file that is
there and is not an `applications.json`, or has a rule that is not valid, is an error: the daemon
does not start with it, and a reload with it fails and logs the error. Only a file with the
extension `.json` is read.
## The file komorebi ships
[`komorebic/applications.json`](../../komorebic/applications.json) in the repository has an
entry for KDE Plasma, which floats the calculators of KDE and GNOME, the screenshot tool, the
authentication dialog of Plasma and System Settings. A test loads it, and opens the windows it
names.
+1
View File
@@ -96,6 +96,7 @@ can have values of their own, which come before the default.
| `ignore_rules` | Windows komorebi leaves alone (`float_rules` is the same key under its old name) |
| `manage_rules` | Windows komorebi tiles whatever the ignore rules say |
| `floating_applications` | Windows that open floating |
| `app_specific_configuration_path` | One `applications.json`, or a list of them, whose rules are added to these ([Application specific configuration](application-specific-configuration.md)) |
Each is a list of rules, which [Rules](rules.md) explains. A rule is an object with `kind` (`Exe`,
`Class`, `Title` or `Path`), `id` and `matching_strategy` (`Equals`, `StartsWith`, `EndsWith`,
+1
View File
@@ -74,6 +74,7 @@ pub use komorebi::core::SocketMessage;
pub use komorebi::core::StateQuery;
pub use komorebi::core::SubscribeOptions;
pub use komorebi::core::WindowKind;
pub use komorebi::core::asc::ApplicationSpecificConfiguration;
pub use komorebi::core::pathext::PathExt;
pub use komorebi::core::pathext::replace_env_in_path;
pub use komorebi::state::State;
+69
View File
@@ -0,0 +1,69 @@
//! The application specific configuration file (`app_specific_configuration_path`): rules, by
//! application, for the windows komorebi ignores, manages or floats.
use crate::core::config_generation::MatchingRule;
use color_eyre::Result;
use serde::Deserialize;
use serde::Serialize;
use std::collections::BTreeMap;
use std::ops::Deref;
use std::ops::DerefMut;
use std::path::PathBuf;
#[derive(Clone, Debug, Serialize, Deserialize)]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
pub struct ApplicationSpecificConfiguration(pub BTreeMap<String, AscApplicationRulesOrSchema>);
#[derive(Clone, Debug, Serialize, Deserialize)]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[serde(untagged)]
pub enum AscApplicationRulesOrSchema {
AscApplicationRules(AscApplicationRules),
Schema(String),
}
impl Deref for ApplicationSpecificConfiguration {
type Target = BTreeMap<String, AscApplicationRulesOrSchema>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl DerefMut for ApplicationSpecificConfiguration {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl ApplicationSpecificConfiguration {
pub fn load(pathbuf: &PathBuf) -> Result<Self> {
let content = std::fs::read_to_string(pathbuf)?;
Ok(serde_json::from_str(&content)?)
}
pub fn format(pathbuf: &PathBuf) -> Result<String> {
Ok(serde_json::to_string_pretty(&Self::load(pathbuf)?)?)
}
}
/// Rules that determine how an application is handled
#[derive(Clone, Debug, Serialize, Deserialize)]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
pub struct AscApplicationRules {
/// Rules to ignore specific windows
#[serde(skip_serializing_if = "Option::is_none")]
pub ignore: Option<Vec<MatchingRule>>,
/// Rules to forcibly manage specific windows
#[serde(skip_serializing_if = "Option::is_none")]
pub manage: Option<Vec<MatchingRule>>,
/// Rules to manage specific windows as floating windows
#[serde(skip_serializing_if = "Option::is_none")]
pub floating: Option<Vec<MatchingRule>>,
/// Rules to identify applications which are title-less - only accepts Simple Exe rules
#[serde(skip_serializing_if = "Option::is_none")]
pub titleless: Option<Vec<MatchingRule>>,
/// Rules to identify applications which are title-less - only accepts Simple Exe rules
#[serde(skip_serializing_if = "Option::is_none")]
pub tabbed: Option<Vec<MatchingRule>>,
}
+1
View File
@@ -45,6 +45,7 @@ pub use komorebi_layouts::Sizing;
pub use komorebi_layouts::validate_ratios;
// Keep local modules that aren't in komorebi-layouts
pub mod asc;
pub mod config_generation;
pub mod pathext;
+143
View File
@@ -13,6 +13,10 @@
//! nothing on KDE Plasma is accepted and ignored, and a key that is not known at all is ignored
//! too, as serde does.
//!
//! The rules for particular applications are kept in files of their own, which the configuration
//! names with `app_specific_configuration_path` ([`ApplicationSpecificConfiguration`]); their
//! rules are added to the ones the configuration itself has.
//!
//! Settings that have no key are left to their defaults ([`DEFAULT_RESIZE_DELTA`],
//! [`DEFAULT_WORKSPACE_PADDING`] and the others in [`crate`]), and an optional key set to `null`
//! is the same as one that is left out.
@@ -45,8 +49,11 @@ use crate::core::SocketMessage;
use crate::core::WindowContainerBehaviour;
use crate::core::WindowHidingPosition;
use crate::core::WindowManagementBehaviour;
use crate::core::asc::ApplicationSpecificConfiguration;
use crate::core::asc::AscApplicationRulesOrSchema;
use crate::core::config_generation::MatchingRule;
use crate::core::config_generation::MatchingStrategy;
use crate::core::pathext::ResolvedPathBuf;
use crate::monitor::Monitor;
use crate::ring::Ring;
use crate::window::AspectRatio;
@@ -302,6 +309,18 @@ impl From<&Monitor> for MonitorConfig {
}
}
#[serde_with::serde_as]
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
#[serde(untagged)]
/// Path(s) to application-specific configuration file(s)
pub enum AppSpecificConfigurationPath {
/// A single applications.json file
Single(#[serde_as(as = "ResolvedPathBuf")] PathBuf),
/// Multiple applications.json files
Multiple(#[serde_as(as = "Vec<ResolvedPathBuf>")] Vec<PathBuf>),
}
#[serde_with::serde_as]
#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
@@ -365,6 +384,10 @@ pub struct StaticConfig {
#[serde(skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "schemars", schemars(extend("default" = DEFAULT_MOUSE_FOLLOWS_FOCUS)))]
pub mouse_follows_focus: Option<bool>,
/// Path to an applications.json, or a list of them, with rules for the applications that
/// need them: which windows to ignore, to manage and to float
#[serde(skip_serializing_if = "Option::is_none")]
pub app_specific_configuration_path: Option<AppSpecificConfigurationPath>,
/// Global default workspace padding
#[serde(skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "schemars", schemars(extend("default" = DEFAULT_WORKSPACE_PADDING)))]
@@ -515,6 +538,7 @@ impl From<&WindowManager> for StaticConfig {
// minimum_window_height: Some(window::MINIMUM_HEIGHT.load(Ordering::SeqCst)),
// minimum_window_width: Some(window::MINIMUM_WIDTH.load(Ordering::SeqCst)),
mouse_follows_focus: Option::from(value.mouse_follows_focus),
app_specific_configuration_path: None,
default_workspace_padding: Option::from(
DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst),
),
@@ -711,6 +735,29 @@ impl StaticConfig {
// }
// }
//
if let Some(path) = &self.app_specific_configuration_path {
match path {
AppSpecificConfigurationPath::Single(path) => handle_asc_file(
path,
&mut ignore_identifiers,
&mut manage_identifiers,
&mut floating_applications,
&mut regex_identifiers,
)?,
AppSpecificConfigurationPath::Multiple(paths) => {
for path in paths {
handle_asc_file(
path,
&mut ignore_identifiers,
&mut manage_identifiers,
&mut floating_applications,
&mut regex_identifiers,
)?
}
}
}
}
// if let Some(behaviour) = self.window_handling_behaviour {
// WINDOW_HANDLING_BEHAVIOUR.store(behaviour);
// }
@@ -1101,6 +1148,63 @@ fn populate_rules(
Ok(())
}
/// Adds the rules of the applications.json at `path` to the lists the window manager decides by
///
/// A file that is not there is skipped with a warning: one `komorebi.json` is meant to work on
/// every platform, and the file it points to may be one that another platform has
/// (`applications.mac.json` on a KDE desktop). A file that is there and is not an applications.json
/// is an error. Only a file with the extension `json` is read. The rules to ignore, to manage and
/// to float of every application in the file are added; the other kinds of rule that file can
/// have (`titleless` and `tabbed`) are about how another platform exposes windows, and are
/// ignored.
#[allow(clippy::too_many_arguments)]
fn handle_asc_file(
path: &PathBuf,
ignore_identifiers: &mut Vec<MatchingRule>,
manage_identifiers: &mut Vec<MatchingRule>,
floating_applications: &mut Vec<MatchingRule>,
regex_identifiers: &mut HashMap<String, Regex>,
) -> eyre::Result<()> {
// One komorebi.json is meant to work on every platform, and the file it points to is one that
// another platform has (applications.mac.json on a KDE desktop): warn and carry on
if !path.exists() {
tracing::warn!(
"the application specific configuration {} does not exist, ignoring it",
path.display()
);
return Ok(());
}
match path.extension() {
Some(ext) if ext.to_string_lossy().to_string().as_str() == "json" => {
tracing::info!("loading applications.json from: {}", path.display());
let mut asc = ApplicationSpecificConfiguration::load(path)?;
for entry in asc.values_mut() {
match entry {
AscApplicationRulesOrSchema::Schema(_) => {}
AscApplicationRulesOrSchema::AscApplicationRules(entry) => {
if let Some(rules) = &mut entry.ignore {
populate_rules(rules, ignore_identifiers, regex_identifiers)?;
}
if let Some(rules) = &mut entry.manage {
populate_rules(rules, manage_identifiers, regex_identifiers)?;
}
if let Some(rules) = &mut entry.floating {
populate_rules(rules, floating_applications, regex_identifiers)?;
}
}
}
}
}
_ => {}
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
@@ -1159,4 +1263,43 @@ mod tests {
assert!(StaticConfig::read(&path).is_err());
}
#[test]
fn a_missing_application_specific_configuration_is_skipped_not_fatal() {
let (mut ignore, mut manage, mut floating) = (Vec::new(), Vec::new(), Vec::new());
let mut regexes = HashMap::new();
handle_asc_file(
&PathBuf::from(
"/nonexistent/komorebi-application-specific-configuration/applications.mac.json",
),
&mut ignore,
&mut manage,
&mut floating,
&mut regexes,
)
.unwrap();
assert!(ignore.is_empty() && manage.is_empty() && floating.is_empty());
}
#[test]
fn an_application_specific_configuration_that_exists_but_is_broken_is_still_an_error() {
let path = PathBuf::from(format!(
"/tmp/komorebi-asc-test-{}.json",
std::process::id()
));
std::fs::write(&path, "{ not json").unwrap();
let result = handle_asc_file(
&path,
&mut Vec::new(),
&mut Vec::new(),
&mut Vec::new(),
&mut HashMap::new(),
);
let _ = std::fs::remove_file(&path);
assert!(result.is_err());
}
}
+229
View File
@@ -0,0 +1,229 @@
//! The application specific configuration against an in-memory desktop: the `applications.json`
//! files a `komorebi.json` names with `app_specific_configuration_path`, and what the rules in
//! them do to the windows that open.
//!
//! The rule lists are process-wide, so every test names the applications of its own, and each
//! loads its configuration the way the daemon does. Window ids are in the 39_000s.
use color_eyre::eyre;
use komorebi::backend::fake::FakeBackend;
use komorebi::backend::with_backend;
use komorebi::core::asc::ApplicationSpecificConfiguration;
use komorebi::core::asc::AscApplicationRulesOrSchema;
use komorebi::static_config::StaticConfig;
use komorebi::window::Window;
use komorebi::window_manager::WindowManager;
use komorebi::window_manager_event::KWinNotification;
use komorebi::window_manager_event::SystemNotification;
use komorebi::window_manager_event::WindowManagerEvent;
use std::os::unix::net::UnixListener;
use std::path::Path;
use std::path::PathBuf;
use std::sync::Arc;
use std::sync::atomic::AtomicU32;
use std::sync::atomic::Ordering;
/// A path for a file or a socket of a test, short enough for a unix socket path on macOS
fn short_path(suffix: &str) -> PathBuf {
static NEXT: AtomicU32 = AtomicU32::new(0);
PathBuf::from(format!(
"/tmp/kma-{}-{}.{suffix}",
std::process::id(),
NEXT.fetch_add(1, Ordering::SeqCst)
))
}
fn write(suffix: &str, text: &str) -> PathBuf {
let path = short_path(suffix);
std::fs::write(&path, text).unwrap();
path
}
fn added(id: u32) -> WindowManagerEvent {
WindowManagerEvent::Show(
SystemNotification::KWin(KWinNotification::WindowAdded),
Window::from(id),
)
}
/// What the tests find out about a window the desktop opened
#[derive(Debug, PartialEq)]
enum Where {
Tiled,
Floating,
Unmanaged,
}
struct Desktop {
fake: Arc<FakeBackend>,
wm: WindowManager,
}
impl Desktop {
/// Loads a `komorebi.json` with `config` in it over a fake desktop, as the daemon does
fn load(config: &str) -> eyre::Result<Self> {
let fake = Arc::new(FakeBackend::with_one_monitor());
let path = write("json", config);
let (_sender, receiver) = crossbeam_channel::bounded(1);
let socket = short_path("sock");
let wm = with_backend(fake.clone(), || -> eyre::Result<WindowManager> {
let mut wm =
StaticConfig::preload(&path, receiver, Some(UnixListener::bind(&socket)?))?;
wm.init()?;
Ok(wm)
});
let _ = std::fs::remove_file(&socket);
let _ = std::fs::remove_file(&path);
Ok(Self { fake, wm: wm? })
}
/// Opens a window of an application, and says what became of it
fn open(&mut self, id: u32, exe: &str, class: &str) -> Where {
self.fake
.open_window(id, exe, class, &format!("window {id}"));
with_backend(self.fake.clone(), || self.wm.process_event(added(id))).unwrap();
let workspace = self.wm.focused_workspace().unwrap();
if workspace.containers().iter().any(|c| c.contains_window(id)) {
Where::Tiled
} else if workspace.floating_windows().iter().any(|w| w.id == id) {
Where::Floating
} else {
Where::Unmanaged
}
}
}
fn applications(path: &Path) -> String {
format!(
r#"{{ "app_specific_configuration_path": {:?} }}"#,
path.display().to_string()
)
}
#[test]
fn the_rules_of_an_applications_file_ignore_manage_and_float_windows() {
let file = write(
"json",
r#"{
"asc one": {
"ignore": [{ "kind": "Exe", "id": "asc-ignored", "matching_strategy": "Equals" }],
"floating": [{ "kind": "Class", "id": "asc-floated", "matching_strategy": "Equals" }]
},
"asc two": {
"manage": [{ "kind": "Exe", "id": "asc-managed", "matching_strategy": "Equals" }]
}
}"#,
);
let mut desktop = Desktop::load(&applications(&file)).unwrap();
assert_eq!(desktop.open(39_001, "asc-ignored", "x"), Where::Unmanaged);
assert_eq!(desktop.open(39_002, "foot", "asc-floated"), Where::Floating);
assert_eq!(desktop.open(39_003, "asc-managed", "x"), Where::Tiled);
assert_eq!(desktop.open(39_004, "foot", "foot"), Where::Tiled);
let _ = std::fs::remove_file(file);
}
#[test]
fn every_file_of_a_list_is_read() {
let first = write(
"json",
r#"{ "a": { "ignore": [{ "kind": "Exe", "id": "list-first", "matching_strategy": "Equals" }] } }"#,
);
let second = write(
"json",
r#"{ "b": { "ignore": [{ "kind": "Exe", "id": "list-second", "matching_strategy": "Equals" }] } }"#,
);
let mut desktop = Desktop::load(&format!(
r#"{{ "app_specific_configuration_path": [{:?}, {:?}] }}"#,
first.display().to_string(),
second.display().to_string()
))
.unwrap();
assert_eq!(desktop.open(39_011, "list-first", "x"), Where::Unmanaged);
assert_eq!(desktop.open(39_012, "list-second", "x"), Where::Unmanaged);
assert_eq!(desktop.open(39_013, "foot", "foot"), Where::Tiled);
let _ = (std::fs::remove_file(first), std::fs::remove_file(second));
}
#[test]
fn the_rules_of_the_configuration_and_of_the_file_add_up() {
let file = write(
"json",
r#"{ "a": { "ignore": [{ "kind": "Exe", "id": "sum-file", "matching_strategy": "Equals" }] } }"#,
);
let mut desktop = Desktop::load(&format!(
r#"{{
"app_specific_configuration_path": {:?},
"ignore_rules": [{{ "kind": "Exe", "id": "sum-config", "matching_strategy": "Equals" }}]
}}"#,
file.display().to_string()
))
.unwrap();
assert_eq!(desktop.open(39_021, "sum-file", "x"), Where::Unmanaged);
assert_eq!(desktop.open(39_022, "sum-config", "x"), Where::Unmanaged);
let _ = std::fs::remove_file(file);
}
#[test]
fn a_file_that_is_not_there_is_skipped_and_one_that_is_broken_is_an_error() {
let missing = short_path("json");
let mut desktop = Desktop::load(&applications(&missing)).unwrap();
assert_eq!(desktop.open(39_031, "foot", "foot"), Where::Tiled);
let broken = write("json", "{ not json");
let error = Desktop::load(&applications(&broken))
.err()
.expect("a broken file is an error");
assert!(!error.to_string().is_empty());
let _ = std::fs::remove_file(broken);
}
#[test]
fn the_kinds_of_rule_of_other_platforms_are_read_and_do_nothing() {
let file = write(
"json",
r#"{
"$schema": "https://example.invalid/applications.schema.json",
"kde": {
"titleless": [{ "kind": "Exe", "id": "other-platform", "matching_strategy": "Equals" }],
"tabbed": [{ "kind": "Exe", "id": "other-platform", "matching_strategy": "Equals" }]
}
}"#,
);
let mut desktop = Desktop::load(&applications(&file)).unwrap();
assert_eq!(desktop.open(39_041, "other-platform", "x"), Where::Tiled);
// the `$schema` entry is the text of a schema's address, and the rest are applications
let loaded = ApplicationSpecificConfiguration::load(&file).unwrap();
assert!(matches!(
loaded["$schema"],
AscApplicationRulesOrSchema::Schema(_)
));
assert!(matches!(
loaded["kde"],
AscApplicationRulesOrSchema::AscApplicationRules(_)
));
let _ = std::fs::remove_file(file);
}
#[test]
fn the_applications_file_komorebic_ships_floats_the_programs_it_names() {
let shipped = Path::new(env!("CARGO_MANIFEST_DIR")).join("../komorebic/applications.json");
let mut desktop = Desktop::load(&applications(&shipped)).unwrap();
assert_eq!(
desktop.open(39_051, "kcalc", "org.kde.kcalc"),
Where::Floating
);
assert_eq!(
desktop.open(39_052, "systemsettings", "org.kde.systemsettings"),
Where::Floating
);
assert_eq!(desktop.open(39_053, "kate", "org.kde.kate"), Where::Tiled);
}
-2
View File
@@ -43,8 +43,6 @@ const WINDOWS_ONLY: &[&str] = &[
/// ignored until then. Each comment says which commit of the plan brings the feature, and takes
/// the key off this list.
const NOT_YET: &[&str] = &[
// application specific configuration (39)
"app_specific_configuration_path",
// borders drawn by the compositor (43)
"border",
"border_colours",
+11
View File
@@ -0,0 +1,11 @@
{
"KDE Plasma": {
"floating": [
{ "kind": "Class", "id": "org.kde.kcalc", "matching_strategy": "Equals" },
{ "kind": "Class", "id": "org.gnome.Calculator", "matching_strategy": "Equals" },
{ "kind": "Class", "id": "org.kde.spectacle", "matching_strategy": "Equals" },
{ "kind": "Class", "id": "org.kde.polkit-kde-authentication-agent-1", "matching_strategy": "Equals" },
{ "kind": "Class", "id": "org.kde.systemsettings", "matching_strategy": "Equals" }
]
}
}