mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-18 22:58:34 +01:00
feat(cli): quickstart, autostart and the config commands
komorebic quickstart writes an example komorebi.json and applications.json into the config home, asking before it writes over a file, so a new user has a configuration to start from. komorebic enable-autostart writes the XDG autostart entry that has Plasma start komorebi at login, with the komorebi.json it is given if any, and disable-autostart takes it away; the NixOS module does the same job for a machine that has it. komorebic replace-configuration makes the running daemon start over from another komorebi.json: it pauses its window manager and brings back the windows it hid, the back of a stack, so that none is out of sight for the new one to miss, then makes the window manager again from the file, with the monitors and the windows the backend has, and watches the new file in place of the old one. A file that does not read is logged and the daemon carries on as it was.
This commit is contained in:
1 parent
3a3a0f8f24
commit
c6874ff5db
20 files changed
+649
-15
No files matched your search
@@ -83,8 +83,9 @@ without a checkout of the toolchain.
|
||||
daemon, reads its answers, subscribes to its notifications, and re-exports
|
||||
the types they are made of.
|
||||
- [`komorebic`](komorebic): the command line. A subcommand that asks something
|
||||
of the daemon is one message on its socket; `start`, `configuration`, `log`,
|
||||
`data-directory`, `completions` and the hidden `docgen` work without the daemon.
|
||||
of the daemon is one message on its socket; `quickstart`, `enable-autostart`,
|
||||
`disable-autostart`, `start`, `configuration`, `log`, `data-directory`, `completions` and
|
||||
the hidden `docgen` work without the daemon.
|
||||
- [`version`](version): the version string every binary reports.
|
||||
|
||||
The layouts, which turn a work area and a number of containers into a rectangle
|
||||
@@ -206,7 +207,9 @@ 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`. The Rust types that read the file describe it as a JSON Schema
|
||||
has as a `komorebi.json`, and `replace-configuration` makes the daemon start over from
|
||||
another file. `quickstart` writes an example configuration, and `enable-autostart` an
|
||||
autostart entry that has Plasma start komorebi at login. The Rust types that read the file describe it as a JSON Schema
|
||||
(`schema.json`, written by `just jsonschema` and printed by `static-config-schema`), and the
|
||||
module's `config` option is typed from that schema (`nix/komorebi-options.nix`, written by
|
||||
`just nixgen`), so a configuration written in Nix is checked when it is evaluated.
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
```text
|
||||
Removes the XDG autostart entry
|
||||
|
||||
Usage: disable-autostart
|
||||
|
||||
Options:
|
||||
-h, --help
|
||||
Print help
|
||||
|
||||
```
|
||||
@@ -0,0 +1,13 @@
|
||||
```text
|
||||
Writes an XDG autostart entry so komorebi starts with the Plasma session
|
||||
|
||||
Usage: enable-autostart [OPTIONS]
|
||||
|
||||
Options:
|
||||
-c, --config <CONFIG>
|
||||
Path to a static configuration JSON file
|
||||
|
||||
-h, --help
|
||||
Print help
|
||||
|
||||
```
|
||||
@@ -0,0 +1,10 @@
|
||||
```text
|
||||
Gather example configurations for a new-user quickstart
|
||||
|
||||
Usage: quickstart
|
||||
|
||||
Options:
|
||||
-h, --help
|
||||
Print help
|
||||
|
||||
```
|
||||
@@ -0,0 +1,14 @@
|
||||
```text
|
||||
Replace the configuration of a running instance of komorebi from a static configuration file
|
||||
|
||||
Usage: replace-configuration <PATH>
|
||||
|
||||
Arguments:
|
||||
<PATH>
|
||||
Static configuration JSON file from which the configuration should be loaded
|
||||
|
||||
Options:
|
||||
-h, --help
|
||||
Print help
|
||||
|
||||
```
|
||||
@@ -683,6 +683,16 @@ defaults. A **rule** is an entry of one of the process-wide lists. A workspace's
|
||||
`layout_rules`, `work_area_offset_rules` and `window_container_behaviour_rules` are fields of the
|
||||
[`Workspace`], which [`Workspace::update`] reads each time it tiles.
|
||||
|
||||
`ReplaceConfiguration` is the third way in: [`WindowManager::process_command`] checks that the file
|
||||
reads as a [`StaticConfig`], pauses the old window manager and brings back the windows it hid
|
||||
([`WindowManager::restore_all_windows`]), makes a new window manager from the file
|
||||
([`StaticConfig::preload`], [`WindowManager::init`], [`StaticConfig::reload`]) over the same command
|
||||
socket, and puts it where the old one was, so the daemon starts over from the file, with the
|
||||
windows the backend has, all of them in view, and a watcher on the new file. A file that does not read is logged and the old window manager stays.
|
||||
`komorebic quickstart` writes the example file of the docs and `komorebic/applications.json` into
|
||||
the config home, compiled into the binary, and asks before it writes over a file;
|
||||
`komorebic enable-autostart` writes the XDG autostart entry that has Plasma start the daemon at login.
|
||||
|
||||
The same types describe the file as a JSON Schema, which `schemars` derives: `komorebic
|
||||
static-config-schema` prints the schema of [`StaticConfig`], `application-specific-configuration-schema`
|
||||
that of an applications file, and `notification-schema` and `socket-schema` those of a
|
||||
@@ -711,6 +721,10 @@ goes the other way, for `GenerateStaticConfig`.
|
||||
| `schema.json` and `schema.asc.json` are what the Rust types print | Nix check `schema-fresh`, and a test that compares them with `komorebic`'s output | `schema-fresh`, `the_schema_files_of_the_repository_are_what_the_subcommands_print` | `just jsonschema` |
|
||||
| The options the module is typed with are made from the committed schema | the hash of `schema.json` in the first line of `nix/komorebi-options.nix`, compared by `schema-fresh` | `schema-fresh` | `just nixgen` |
|
||||
| The example, in Nix and in JSON, follows the schema, and says the same in both | Nix check `nix-options-validation`: the options evaluated against the Nix example, both examples checked with `check-jsonschema`, and one contained in the other | `nix-options-validation` | none |
|
||||
| Replacing the configuration with a file that does not read leaves the window manager as it was | framework path: the arm reads the file as a [`StaticConfig`] before it makes anything | `replacing_the_configuration_makes_the_window_manager_again_from_the_new_file` | none |
|
||||
| Replacing the configuration leaves no window hidden | framework path: the arm brings back the windows the old window manager hid ([`WindowManager::restore_all_windows`]) before the new one reads the desktop | `replacing_the_configuration_makes_the_window_manager_again_from_the_new_file` | none |
|
||||
| `quickstart` never writes over a file without being told to | framework path: every file goes through `write_file_with_prompt`, which keeps the file unless the answer is `y` or `yes` | `quickstart_writes_the_example_files_and_asks_before_it_overwrites_one` | none |
|
||||
| The entry `enable-autostart` writes is one the session runs | VM test: systemd's autostart generator makes a unit of it, which starts a daemon | `autostart_writes_an_xdg_entry_that_starts_komorebi_and_takes_it_away_again`, `vm-module` | 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 |
|
||||
@@ -1022,7 +1036,8 @@ A window is shown, and ends up on a tile:
|
||||
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;
|
||||
[`komorebi/tests/schemas.rs`](../../komorebi/tests/schemas.rs) the schemas the daemon answers
|
||||
[`komorebi/tests/replace_configuration.rs`](../../komorebi/tests/replace_configuration.rs)
|
||||
the `ReplaceConfiguration` message; [`komorebi/tests/schemas.rs`](../../komorebi/tests/schemas.rs) the schemas the daemon answers
|
||||
with; [`schema.json`](../../schema.json), [`schema.asc.json`](../../schema.asc.json) and
|
||||
[`nix/komorebi-options.nix`](../../nix/komorebi-options.nix), which are generated;
|
||||
[`nix/tests/default.nix`](../../nix/tests/default.nix) and
|
||||
|
||||
@@ -363,3 +363,12 @@ installed with `cargo install`). `just nixgen` writes the hash of `schema.json`
|
||||
of the file, and the check `schema-fresh` compares that with the hash of the committed schema, and
|
||||
the schema with what `komorebic static-config-schema` prints. A change to a key that leaves the
|
||||
schema or the options behind fails the check, with no tool but the build.
|
||||
|
||||
## Why does `komorebic` write an autostart entry, as well as the module having a unit?
|
||||
|
||||
The module is NixOS, and the daemon runs on other distributions too. An XDG autostart entry is
|
||||
what a Plasma session runs at login for a program that is not part of it, so
|
||||
`komorebic enable-autostart` writes one, with the `komorebi.json` it is given if any. The entry is
|
||||
ordered after `plasma-workspace` (`X-KDE-autostart-after`), as the module's unit is ordered after
|
||||
`plasma-core.target`: the daemon exits when KWin is not on the session bus. The entry and the
|
||||
unit do not go together, since the session bus gives its name to one komorebi.
|
||||
@@ -233,6 +233,7 @@ since a read right after `createDesktop` has to see the new desktop.
|
||||
| Path | What | Lifetime |
|
||||
|---|---|---|
|
||||
| `$KOMOREBI_CONFIG_HOME/komorebi.json` (`~/.config/komorebi/komorebi.json`) | komorebi's configuration, which komorebi never writes: read when the daemon starts, and again when it changes. `--config` names another file | the user's |
|
||||
| `$XDG_CONFIG_HOME/autostart/komorebi.desktop` (`~/.config/autostart/komorebi.desktop`) | the XDG autostart entry `komorebic enable-autostart` writes: `Exec=komorebi`, or `komorebi --config "FILE"`, and `X-KDE-autostart-after=plasma-workspace`, which a Plasma session starts komorebi from at login | the user's; `komorebic disable-autostart` removes it |
|
||||
| `$XDG_CONFIG_HOME/kwinrc` (`~/.config/kwinrc`) | KWin's configuration: komorebi sets `PerOutputVirtualDesktops=true` in `[Windows]`, changing that line or adding it and nothing else, and writes the file beside it first and renames it over it | put back as it was when the daemon stops |
|
||||
| `$XDG_RUNTIME_DIR/komorebi/kwinrc-backup.json` | the value each key of `kwinrc` had before komorebi first changed it | removed when the values are put back; one a crash left behind is used by the next run |
|
||||
| `$XDG_RUNTIME_DIR/komorebi/bridge.js` | the script KWin loads, with its configuration (the D-Bus names and the hold time of `Poll`) on its first line | written at every start; the directory is removed at logout |
|
||||
@@ -300,6 +301,15 @@ When set to anything but the empty string, the log the daemon prints on its stan
|
||||
has no ANSI colors, which is what standard output redirected to a file wants. The VM tests
|
||||
set it. The log files are not affected: one has colors and the other none.
|
||||
|
||||
## The autostart entry
|
||||
|
||||
At time of writing (2026-10-27), on a Plasma session of a NixOS machine, systemd's autostart
|
||||
generator makes a user unit of the entry `komorebic enable-autostart` writes,
|
||||
`app-komorebi@autostart.service`, when the user manager reloads (`systemctl --user
|
||||
daemon-reload`), and starting that unit starts a daemon that follows the file the entry gave it
|
||||
(`vm-module`, which does this on x86_64). The test starts the unit by hand, since the session it
|
||||
runs in has logged in already: it does not show that the next login starts it.
|
||||
|
||||
## Watching the configuration
|
||||
|
||||
The daemon watches `komorebi.json` with `hotwatch` 0.5, over `notify` 6.1, which on Linux is
|
||||
|
||||
@@ -63,8 +63,9 @@ different layout. This page has the file as it is:
|
||||
}
|
||||
```
|
||||
|
||||
Put it where the daemon looks for it, `~/.config/komorebi/komorebi.json`, or give it to the daemon
|
||||
with `komorebic start --config`. [Configuration](usage/configuration.md) explains every key and
|
||||
`komorebic quickstart` writes it, and the `applications.json` below, where the daemon looks for
|
||||
them ([Quickstart and autostart](usage/quickstart-and-autostart.md)). Or put it there yourself,
|
||||
`~/.config/komorebi/komorebi.json`, or give it to the daemon with `komorebic start --config`. [Configuration](usage/configuration.md) explains every key and
|
||||
where the daemon looks. The settings of a monitor with more than one entry in `monitors`, and of
|
||||
each workspace, are there too.
|
||||
|
||||
@@ -72,8 +73,9 @@ each workspace, are there too.
|
||||
|
||||
`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.
|
||||
[`komorebic/applications.json`](../komorebic/applications.json). `komorebic quickstart` puts 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.
|
||||
|
||||
|
||||
@@ -54,6 +54,9 @@ are KWin's virtual desktops, and how to show another or move a window to one.
|
||||
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.
|
||||
[Quickstart and autostart](usage/quickstart-and-autostart.md) explains how to write an example
|
||||
configuration, how to start komorebi with Plasma without the module, and how to replace the
|
||||
configuration of a running daemon.
|
||||
[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.
|
||||
|
||||
@@ -157,8 +157,9 @@ cargo install --locked --path komorebic
|
||||
`cargo` installs both in `~/.cargo/bin`, which has to be on your `PATH`. Start komorebi from a
|
||||
terminal in your Plasma session with [`komorebic start`](cli/start.md).
|
||||
|
||||
To start it with every Plasma session instead, write the unit the NixOS module defines, without
|
||||
the NixOS paths, to `~/.config/systemd/user/komorebi.service`:
|
||||
To start it with every Plasma session instead, `komorebic enable-autostart` writes an autostart
|
||||
entry ([Quickstart and autostart](usage/quickstart-and-autostart.md)), or you can write the unit
|
||||
the NixOS module defines, without the NixOS paths, to `~/.config/systemd/user/komorebi.service`:
|
||||
|
||||
```ini
|
||||
[Unit]
|
||||
|
||||
@@ -0,0 +1,57 @@
|
||||
# Quickstart and autostart
|
||||
|
||||
## Quickstart
|
||||
|
||||
[`komorebic quickstart`](../cli/quickstart.md) writes two example files into the config home
|
||||
(`~/.config/komorebi`, or `$KOMOREBI_CONFIG_HOME`), which it makes if it has to:
|
||||
|
||||
- `komorebi.json`, which is [`docs/komorebi.example.json`](../example-configurations.md):
|
||||
eight workspaces on the first monitor, each with another layout, and some padding;
|
||||
- `applications.json`, which is
|
||||
[`komorebic/applications.json`](application-specific-configuration.md#the-file-komorebi-ships),
|
||||
the rules `komorebi.json` names for the applications that need them.
|
||||
|
||||
When a file is there already, `quickstart` asks before it writes over it, and leaves the file
|
||||
alone unless the answer is `y` or `yes`. It prints the files it wrote, and then tells you to run
|
||||
`komorebic start`.
|
||||
|
||||
```sh
|
||||
komorebic quickstart
|
||||
komorebic start
|
||||
```
|
||||
|
||||
## Starting komorebi with Plasma
|
||||
|
||||
On NixOS, [the module](../installation.md#nixos) starts komorebi with every Plasma session.
|
||||
Elsewhere, [`komorebic enable-autostart`](../cli/enable-autostart.md) writes an XDG autostart
|
||||
entry, `~/.config/autostart/komorebi.desktop` (`$XDG_CONFIG_HOME/autostart`), which Plasma runs at
|
||||
login, after its workspace has started:
|
||||
|
||||
```sh
|
||||
komorebic enable-autostart
|
||||
komorebic enable-autostart --config ~/mine.json
|
||||
```
|
||||
|
||||
The entry runs `komorebi`, or `komorebi --config` with the file `--config` names, as the session
|
||||
finds `komorebi` on its `PATH`. [`komorebic disable-autostart`](../cli/disable-autostart.md) takes
|
||||
the entry away again, and says so when there is none.
|
||||
|
||||
Do not use both the module and the entry: the session bus gives its name to one komorebi, and the
|
||||
second exits.
|
||||
|
||||
## Starting over with another file
|
||||
|
||||
[`komorebic replace-configuration`](../cli/replace-configuration.md) makes the running daemon start
|
||||
over from another `komorebi.json`:
|
||||
|
||||
```sh
|
||||
komorebic replace-configuration ~/work.json
|
||||
```
|
||||
|
||||
The daemon makes its window manager again from the file, as it does at start: it brings back
|
||||
the windows it had hidden, the back of a stack, so that none is out of sight, loads the monitors
|
||||
and the windows that are open from KWin, gives the monitors the entries of the file and tiles
|
||||
them, and from then on watches the new file and not the one it had. It is not the same as
|
||||
changing the file the daemon watches, which [Configuration](configuration.md#changing-the-file)
|
||||
describes: the windows that were in a workspace go where the new file puts them, not where they
|
||||
were. A file that is not a `komorebi.json` is logged, and the daemon carries on as it was.
|
||||
@@ -36,7 +36,8 @@ session. Outside a Plasma session it exits with an error that says what is missi
|
||||
`komorebic start` prints.
|
||||
|
||||
`--config` gives the daemon the `komorebi.json` to read
|
||||
([Configuration](configuration.md) says where it looks otherwise):
|
||||
([Configuration](configuration.md) says where it looks otherwise), and
|
||||
[`komorebic quickstart`](quickstart-and-autostart.md) writes one to start from:
|
||||
|
||||
```sh
|
||||
komorebic start --config ~/mine.json
|
||||
|
||||
@@ -464,6 +464,7 @@ pub enum SocketMessage {
|
||||
ToggleWorkspaceLayer,
|
||||
// Configuration
|
||||
// ReloadConfiguration,
|
||||
ReplaceConfiguration(#[serde_as(as = "ResolvedPathBuf")] PathBuf),
|
||||
ReloadStaticConfiguration(#[serde_as(as = "ResolvedPathBuf")] PathBuf),
|
||||
// WatchConfiguration(bool),
|
||||
// CompleteConfiguration,
|
||||
|
||||
@@ -74,7 +74,12 @@
|
||||
//! [`WindowManager::clear_workspace_layout_rules`]).
|
||||
//! - **ReloadStaticConfiguration** applies a `komorebi.json` to the window manager
|
||||
//! ([`WindowManager::reload_static_configuration`]). The daemon sends itself this message when
|
||||
//! the file it was started with changes.
|
||||
//! the file it was started with changes. **ReplaceConfiguration** makes the window manager
|
||||
//! again from a `komorebi.json`, which loads the monitors and the windows from the backend as
|
||||
//! the daemon does when it starts, and watches that file instead of the one it had. The old
|
||||
//! window manager is paused and brings back the windows it hid (the back of a stack), so that
|
||||
//! every window is in view for the new one to find; a file that is not a `komorebi.json` is
|
||||
//! logged and changes nothing.
|
||||
//! - **PreselectDirection** reserves the place on one side of the focused container for the next
|
||||
//! window ([`WindowManager::preselect_container_in_direction`]), unless a place is reserved
|
||||
//! already, and **CancelPreselect** gives the reserved place up.
|
||||
@@ -207,6 +212,7 @@ use crate::static_config::StaticConfig;
|
||||
use crate::window::RuleDebug;
|
||||
use crate::window::Window;
|
||||
use crate::window_manager::WindowManager;
|
||||
use crate::window_manager_event_listener;
|
||||
use crate::workspace::WorkspaceLayer;
|
||||
use crate::workspace::WorkspaceWindowLocation;
|
||||
use color_eyre::eyre;
|
||||
@@ -921,6 +927,38 @@ impl WindowManager {
|
||||
let mut display_index_preferences = DISPLAY_INDEX_PREFERENCES.write();
|
||||
display_index_preferences.insert(index_preference, display.clone());
|
||||
}
|
||||
SocketMessage::ReplaceConfiguration(ref config) => {
|
||||
// Check that this is a valid static config file first
|
||||
if StaticConfig::read(config).is_ok() {
|
||||
// Pause so that restored windows come to the foreground from all workspaces
|
||||
self.is_paused = true;
|
||||
// Bring all windows to the foreground
|
||||
self.restore_all_windows(false)?;
|
||||
|
||||
// Create a new wm from the config path
|
||||
let mut wm = StaticConfig::preload(
|
||||
config,
|
||||
window_manager_event_listener::event_rx(),
|
||||
self.command_listener.try_clone().ok(),
|
||||
)?;
|
||||
|
||||
// Initialize the new wm
|
||||
wm.init()?;
|
||||
|
||||
wm.restore_all_windows(true)?;
|
||||
|
||||
// This is equivalent to StaticConfig::postload for this use case
|
||||
StaticConfig::reload(config, &mut wm)?;
|
||||
|
||||
// Set self to the new wm instance
|
||||
*self = wm;
|
||||
} else {
|
||||
tracing::warn!(
|
||||
"not replacing the configuration: {} is not a komorebi.json",
|
||||
config.display()
|
||||
);
|
||||
}
|
||||
}
|
||||
SocketMessage::NewWorkspace => {
|
||||
self.new_workspace()?;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,160 @@
|
||||
//! `ReplaceConfiguration` against an in-memory desktop: the window manager that is running is
|
||||
//! made again from another `komorebi.json`, with the windows the desktop has.
|
||||
//!
|
||||
//! The settings a file sets are process-wide, so this file is one test. Window ids are in the
|
||||
//! 41_000s.
|
||||
|
||||
use komorebi::backend::fake::FakeBackend;
|
||||
use komorebi::backend::with_backend;
|
||||
use komorebi::core::OperationDirection;
|
||||
use komorebi::core::Rect;
|
||||
use komorebi::core::SocketMessage;
|
||||
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::PathBuf;
|
||||
use std::sync::Arc;
|
||||
|
||||
fn rect(left: i32, top: i32, right: i32, bottom: i32) -> Rect {
|
||||
Rect {
|
||||
left,
|
||||
top,
|
||||
right,
|
||||
bottom,
|
||||
}
|
||||
}
|
||||
|
||||
fn write(name: &str, json: &str) -> PathBuf {
|
||||
let path = PathBuf::from(format!("/tmp/kmr-{}-{name}.json", std::process::id()));
|
||||
std::fs::write(&path, json).unwrap();
|
||||
path
|
||||
}
|
||||
|
||||
fn workspace_names(wm: &WindowManager) -> Vec<Option<String>> {
|
||||
wm.monitors()[0]
|
||||
.workspaces()
|
||||
.iter()
|
||||
.map(|workspace| workspace.name.clone())
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn replacing_the_configuration_makes_the_window_manager_again_from_the_new_file() {
|
||||
let fake = Arc::new(FakeBackend::with_one_monitor());
|
||||
let first = write(
|
||||
"first",
|
||||
r#"{ "resize_delta": 100, "monitors": [ { "workspaces": [ { "name": "one", "layout": "BSP" } ] } ] }"#,
|
||||
);
|
||||
let socket = PathBuf::from(format!("/tmp/kmr-{}.sock", std::process::id()));
|
||||
let (_sender, receiver) = crossbeam_channel::bounded(1);
|
||||
|
||||
let mut wm = with_backend(fake.clone(), || {
|
||||
let mut wm =
|
||||
StaticConfig::preload(&first, receiver, Some(UnixListener::bind(&socket).unwrap()))
|
||||
.unwrap();
|
||||
wm.init().unwrap();
|
||||
wm
|
||||
});
|
||||
fake.open_window(41_001, "foot", "foot", "terminal");
|
||||
with_backend(fake.clone(), || {
|
||||
wm.process_event(WindowManagerEvent::Show(
|
||||
SystemNotification::KWin(KWinNotification::WindowAdded),
|
||||
Window::from(41_001),
|
||||
))
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(wm.resize_delta, 100);
|
||||
assert_eq!(fake.rect_of(41_001), Some(rect(10, 10, 1900, 1030)));
|
||||
|
||||
let second = write(
|
||||
"second",
|
||||
r#"{
|
||||
"resize_delta": 30,
|
||||
"default_workspace_padding": 0,
|
||||
"default_container_padding": 0,
|
||||
"monitors": [ { "workspaces": [ { "name": "uno", "layout": "Columns" }, { "name": "dos" } ] } ]
|
||||
}"#,
|
||||
);
|
||||
with_backend(fake.clone(), || {
|
||||
wm.process_command(
|
||||
SocketMessage::ReplaceConfiguration(second.clone()),
|
||||
Vec::new(),
|
||||
)
|
||||
})
|
||||
.unwrap();
|
||||
|
||||
// a window manager made from the new file, which found the window the desktop has
|
||||
assert_eq!(wm.resize_delta, 30);
|
||||
assert_eq!(
|
||||
workspace_names(&wm),
|
||||
[Some(String::from("uno")), Some(String::from("dos"))]
|
||||
);
|
||||
assert_eq!(fake.rect_of(41_001), Some(rect(0, 0, 1920, 1050)));
|
||||
assert!(wm.monitors()[0].workspaces()[0].contains_window(41_001));
|
||||
|
||||
// a file that is not a configuration changes nothing, and does not stop the daemon
|
||||
let broken = write("broken", r#"{ "resize_delta": "wide" "#);
|
||||
with_backend(fake.clone(), || {
|
||||
wm.process_command(
|
||||
SocketMessage::ReplaceConfiguration(broken.clone()),
|
||||
Vec::new(),
|
||||
)
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(wm.resize_delta, 30);
|
||||
assert_eq!(workspace_names(&wm).len(), 2);
|
||||
|
||||
// the back window of a stack is out of sight, and the new window manager would not find it
|
||||
// there: the old one brings it back before the new one looks at the desktop
|
||||
fake.open_window(41_002, "foot", "foot", "terminal");
|
||||
for event in [
|
||||
WindowManagerEvent::Show(
|
||||
SystemNotification::KWin(KWinNotification::WindowAdded),
|
||||
Window::from(41_002),
|
||||
),
|
||||
WindowManagerEvent::FocusChange(
|
||||
SystemNotification::KWin(KWinNotification::WindowActivated),
|
||||
Window::from(41_002),
|
||||
),
|
||||
] {
|
||||
fake.set_foreground(Some(41_002));
|
||||
with_backend(fake.clone(), || wm.process_event(event)).unwrap();
|
||||
}
|
||||
with_backend(fake.clone(), || {
|
||||
wm.process_command(
|
||||
SocketMessage::StackWindow(OperationDirection::Left),
|
||||
Vec::new(),
|
||||
)
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
[41_001, 41_002]
|
||||
.iter()
|
||||
.filter(|id| fake.is_hidden(**id))
|
||||
.count(),
|
||||
1
|
||||
);
|
||||
|
||||
with_backend(fake.clone(), || {
|
||||
wm.process_command(
|
||||
SocketMessage::ReplaceConfiguration(second.clone()),
|
||||
Vec::new(),
|
||||
)
|
||||
})
|
||||
.unwrap();
|
||||
assert!(!fake.is_hidden(41_001) && !fake.is_hidden(41_002));
|
||||
assert_eq!(
|
||||
wm.focused_workspace().unwrap().containers().len(),
|
||||
2,
|
||||
"the new window manager found both windows, each with a tile"
|
||||
);
|
||||
|
||||
let _ = std::fs::remove_file(&socket);
|
||||
for path in [first, second, broken] {
|
||||
let _ = std::fs::remove_file(path);
|
||||
}
|
||||
}
|
||||
+122
-2
@@ -75,13 +75,17 @@
|
||||
//! `workspace-layout-rule` and `named-workspace-layout-rule` make a workspace change layout once
|
||||
//! it has so many windows, and `clear-workspace-layout-rules` and
|
||||
//! `clear-named-workspace-layout-rules` take those rules away. `generate-static-config` prints the
|
||||
//! settings of the daemon as a `komorebi.json`.
|
||||
//! settings of the daemon as a `komorebi.json`, and `replace-configuration` makes the daemon
|
||||
//! start over with another one.
|
||||
//!
|
||||
//! `subscribe-socket` and `unsubscribe-socket` add and remove a subscriber: a program that listens
|
||||
//! on a socket in the daemon's data directory, to which the daemon sends a notification after each
|
||||
//! event and each message it handles.
|
||||
//!
|
||||
//! The others work without the daemon: `start` runs `komorebi` in the background, with the
|
||||
//! The others work without the daemon: `quickstart` writes an example `komorebi.json` and
|
||||
//! `applications.json` in the config home, `enable-autostart` and `disable-autostart` write and
|
||||
//! remove the entry that has Plasma start komorebi at login, `start` runs `komorebi` in the
|
||||
//! background, with the
|
||||
//! `komorebi.json` it is given with `--config`, `configuration` shows the path of the
|
||||
//! `komorebi.json` the daemon reads, `log` follows its log, `data-directory` shows where its
|
||||
//! socket is, `completions` prints a completion script for a shell, and `static-config-schema`,
|
||||
@@ -616,6 +620,21 @@ struct LoadResize {
|
||||
path: PathBuf,
|
||||
}
|
||||
|
||||
#[derive(Parser)]
|
||||
struct ReplaceConfiguration {
|
||||
/// Static configuration JSON file from which the configuration should be loaded
|
||||
#[clap(value_parser = replace_env_in_path)]
|
||||
path: PathBuf,
|
||||
}
|
||||
|
||||
#[derive(Parser)]
|
||||
struct EnableAutostart {
|
||||
/// Path to a static configuration JSON file
|
||||
#[clap(action, short, long)]
|
||||
#[clap(value_parser = replace_env_in_path)]
|
||||
config: Option<PathBuf>,
|
||||
}
|
||||
|
||||
#[derive(Parser)]
|
||||
struct EagerFocus {
|
||||
/// Case-sensitive exe identifier
|
||||
@@ -665,6 +684,8 @@ enum SubCommand {
|
||||
/// Generate komorebic CLI completions for the target shell
|
||||
#[clap(arg_required_else_help = true)]
|
||||
Completions(Completions),
|
||||
/// Gather example configurations for a new-user quickstart
|
||||
Quickstart,
|
||||
/// Start komorebi as a background process
|
||||
Start(Start),
|
||||
/// Stop the komorebi process
|
||||
@@ -1032,6 +1053,9 @@ enum SubCommand {
|
||||
MouseFollowsFocus(MouseFollowsFocus),
|
||||
/// Toggle mouse follows focus on all workspaces
|
||||
ToggleMouseFollowsFocus,
|
||||
/// Replace the configuration of a running instance of komorebi from a static configuration file
|
||||
#[clap(arg_required_else_help = true)]
|
||||
ReplaceConfiguration(ReplaceConfiguration),
|
||||
/// Generate a JSON Schema for applications.json
|
||||
#[clap(alias = "asc-schema")]
|
||||
ApplicationSpecificConfigurationSchema,
|
||||
@@ -1043,6 +1067,18 @@ enum SubCommand {
|
||||
StaticConfigSchema,
|
||||
/// Generates a static configuration JSON file based on the current window manager state
|
||||
GenerateStaticConfig,
|
||||
/// Writes an XDG autostart entry so komorebi starts with the Plasma session
|
||||
EnableAutostart(EnableAutostart),
|
||||
/// Removes the XDG autostart entry
|
||||
DisableAutostart,
|
||||
}
|
||||
|
||||
/// `~/.config/autostart/komorebi.desktop`, which Plasma runs at login
|
||||
fn autostart_entry() -> PathBuf {
|
||||
dirs::config_dir()
|
||||
.expect("there is no config directory")
|
||||
.join("autostart")
|
||||
.join("komorebi.desktop")
|
||||
}
|
||||
|
||||
fn print_query(message: &SocketMessage) {
|
||||
@@ -1094,6 +1130,87 @@ fn main() -> eyre::Result<()> {
|
||||
let mut cli = Opts::command();
|
||||
clap_complete::generate(args.shell, &mut cli, "komorebic", &mut std::io::stdout());
|
||||
}
|
||||
SubCommand::Quickstart => {
|
||||
fn write_file_with_prompt(
|
||||
path: &PathBuf,
|
||||
content: &str,
|
||||
created_files: &mut Vec<String>,
|
||||
) -> eyre::Result<()> {
|
||||
if path.exists() {
|
||||
print!(
|
||||
"{} will be overwritten, do you want to continue? (y/N): ",
|
||||
path.display()
|
||||
);
|
||||
std::io::stdout().flush()?;
|
||||
let mut input = String::new();
|
||||
std::io::stdin().read_line(&mut input)?;
|
||||
let trimmed = input.trim().to_lowercase();
|
||||
if trimmed == "y" || trimmed == "yes" {
|
||||
std::fs::write(path, content)?;
|
||||
created_files.push(path.display().to_string());
|
||||
} else {
|
||||
println!("Skipping {}", path.display());
|
||||
}
|
||||
} else {
|
||||
std::fs::write(path, content)?;
|
||||
created_files.push(path.display().to_string());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
std::fs::create_dir_all(&*HOME_DIR)?;
|
||||
std::fs::create_dir_all(&*komorebi_client::DATA_DIR)?;
|
||||
|
||||
let komorebi_json = include_str!("../../docs/komorebi.example.json").to_string();
|
||||
let komorebi_path = HOME_DIR.join("komorebi.json");
|
||||
let applications_path = HOME_DIR.join("applications.json");
|
||||
|
||||
let mut written_files = Vec::new();
|
||||
|
||||
write_file_with_prompt(&komorebi_path, &komorebi_json, &mut written_files)?;
|
||||
|
||||
let applications_json = include_str!("../applications.json");
|
||||
write_file_with_prompt(&applications_path, applications_json, &mut written_files)?;
|
||||
if written_files.is_empty() {
|
||||
println!("\nNo files were written.")
|
||||
} else {
|
||||
println!(
|
||||
"\nThe following example files were written:\n{}",
|
||||
written_files.join("\n")
|
||||
);
|
||||
}
|
||||
|
||||
println!("\nYou can now run: komorebic start");
|
||||
}
|
||||
SubCommand::EnableAutostart(args) => {
|
||||
let exec = match args.config {
|
||||
None => String::from("komorebi"),
|
||||
Some(config) => format!("komorebi --config \"{}\"", config.display()),
|
||||
};
|
||||
|
||||
let target = autostart_entry();
|
||||
if let Some(dir) = target.parent() {
|
||||
std::fs::create_dir_all(dir)?;
|
||||
}
|
||||
|
||||
std::fs::write(
|
||||
&target,
|
||||
format!(
|
||||
"[Desktop Entry]\nType=Application\nName=komorebi\nComment=A tiling window manager for KDE Plasma\nExec={exec}\nX-KDE-autostart-after=plasma-workspace\nTerminal=false\n"
|
||||
),
|
||||
)?;
|
||||
|
||||
println!("Wrote {}", target.display());
|
||||
}
|
||||
SubCommand::DisableAutostart => {
|
||||
let target = autostart_entry();
|
||||
if target.exists() {
|
||||
std::fs::remove_file(&target)?;
|
||||
println!("Deleted {}", target.display());
|
||||
} else {
|
||||
println!("There is no autostart entry at {}", target.display());
|
||||
}
|
||||
}
|
||||
SubCommand::Start(args) => {
|
||||
let mut command = &mut Command::new("komorebi");
|
||||
|
||||
@@ -1675,6 +1792,9 @@ fn main() -> eyre::Result<()> {
|
||||
SubCommand::GenerateStaticConfig => {
|
||||
print_query(&SocketMessage::GenerateStaticConfig);
|
||||
}
|
||||
SubCommand::ReplaceConfiguration(args) => {
|
||||
send_message(&SocketMessage::ReplaceConfiguration(args.path))?;
|
||||
}
|
||||
SubCommand::QuickSaveResize => {
|
||||
send_message(&SocketMessage::QuickSave)?;
|
||||
}
|
||||
|
||||
@@ -678,6 +678,130 @@ fn configuration_shows_the_path_of_komorebi_json_when_there_is_one() {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn replace_configuration_sends_the_path_it_is_given_with_the_variables_replaced() {
|
||||
let runtime = Runtime::new();
|
||||
let daemon = runtime.serve("");
|
||||
|
||||
let output = runtime.komorebic_with_config_home(
|
||||
&runtime.0,
|
||||
&["replace-configuration", "$KOMOREBI_CONFIG_HOME/other.json"],
|
||||
);
|
||||
|
||||
assert!(output.status.success(), "{output:?}");
|
||||
assert_eq!(
|
||||
daemon.join().unwrap(),
|
||||
format!(
|
||||
r#"{{"type":"ReplaceConfiguration","content":"{}/other.json"}}"#,
|
||||
runtime.0.display()
|
||||
)
|
||||
);
|
||||
assert_eq!(stdout(&output), "");
|
||||
}
|
||||
|
||||
/// Runs `komorebic quickstart` in the config home `home`, which answers `answers` to its questions
|
||||
fn quickstart(runtime: &Runtime, home: &Path, answers: &str) -> Output {
|
||||
let mut child = Command::new(env!("CARGO_BIN_EXE_komorebic"))
|
||||
.arg("quickstart")
|
||||
.env("XDG_RUNTIME_DIR", &runtime.0)
|
||||
.env("KOMOREBI_CONFIG_HOME", home)
|
||||
.stdin(std::process::Stdio::piped())
|
||||
.stdout(std::process::Stdio::piped())
|
||||
.stderr(std::process::Stdio::piped())
|
||||
.spawn()
|
||||
.unwrap();
|
||||
child
|
||||
.stdin
|
||||
.take()
|
||||
.unwrap()
|
||||
.write_all(answers.as_bytes())
|
||||
.unwrap();
|
||||
child.wait_with_output().unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn quickstart_writes_the_example_files_and_asks_before_it_overwrites_one() {
|
||||
let runtime = Runtime::new();
|
||||
let home = runtime.0.join("config");
|
||||
std::fs::create_dir_all(&home).unwrap();
|
||||
|
||||
let output = quickstart(&runtime, &home, "");
|
||||
assert!(output.status.success(), "{output:?}");
|
||||
let example = include_str!("../../docs/komorebi.example.json");
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(home.join("komorebi.json")).unwrap(),
|
||||
example
|
||||
);
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(home.join("applications.json")).unwrap(),
|
||||
include_str!("../applications.json")
|
||||
);
|
||||
assert!(stdout(&output).contains("The following example files were written"));
|
||||
assert!(stdout(&output).contains("komorebic start"));
|
||||
|
||||
// a file that is there is kept unless the answer is yes
|
||||
std::fs::write(home.join("komorebi.json"), "{}").unwrap();
|
||||
std::fs::write(home.join("applications.json"), "{}").unwrap();
|
||||
let output = quickstart(&runtime, &home, "n\nyes\n");
|
||||
assert!(output.status.success(), "{output:?}");
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(home.join("komorebi.json")).unwrap(),
|
||||
"{}"
|
||||
);
|
||||
assert_eq!(
|
||||
std::fs::read_to_string(home.join("applications.json")).unwrap(),
|
||||
include_str!("../applications.json")
|
||||
);
|
||||
assert!(stdout(&output).contains("Skipping"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn autostart_writes_an_xdg_entry_that_starts_komorebi_and_takes_it_away_again() {
|
||||
let runtime = Runtime::new();
|
||||
let config_dir = runtime.0.join("xdg");
|
||||
let entry = config_dir.join("autostart").join("komorebi.desktop");
|
||||
let run = |args: &[&str]| {
|
||||
Command::new(env!("CARGO_BIN_EXE_komorebic"))
|
||||
.args(args)
|
||||
.env("XDG_RUNTIME_DIR", &runtime.0)
|
||||
.env("XDG_CONFIG_HOME", &config_dir)
|
||||
.output()
|
||||
.unwrap()
|
||||
};
|
||||
|
||||
let output = run(&["disable-autostart"]);
|
||||
assert!(output.status.success(), "{output:?}");
|
||||
assert!(stdout(&output).contains("There is no autostart entry"));
|
||||
|
||||
let output = run(&["enable-autostart"]);
|
||||
assert!(output.status.success(), "{output:?}");
|
||||
let text = std::fs::read_to_string(&entry).unwrap();
|
||||
assert!(text.starts_with("[Desktop Entry]\n"), "{text}");
|
||||
assert!(text.contains("\nExec=komorebi\n"), "{text}");
|
||||
assert!(
|
||||
text.contains("\nX-KDE-autostart-after=plasma-workspace\n"),
|
||||
"{text}"
|
||||
);
|
||||
|
||||
// `--config` is what the daemon is started with
|
||||
let output = run(&[
|
||||
"enable-autostart",
|
||||
"--config",
|
||||
"/etc/komorebi/komorebi.json",
|
||||
]);
|
||||
assert!(output.status.success(), "{output:?}");
|
||||
assert!(
|
||||
std::fs::read_to_string(&entry)
|
||||
.unwrap()
|
||||
.contains("\nExec=komorebi --config \"/etc/komorebi/komorebi.json\"\n")
|
||||
);
|
||||
|
||||
let output = run(&["disable-autostart"]);
|
||||
assert!(output.status.success(), "{output:?}");
|
||||
assert!(stdout(&output).starts_with("Deleted "), "{output:?}");
|
||||
assert!(!entry.exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_config_home_that_is_not_a_directory_is_refused() {
|
||||
let runtime = Runtime::new();
|
||||
@@ -883,8 +1007,10 @@ fn docgen_writes_the_help_of_every_subcommand_in_a_text_fence() {
|
||||
"cycle-stack.md",
|
||||
"cycle-workspace.md",
|
||||
"data-directory.md",
|
||||
"disable-autostart.md",
|
||||
"display-index-preference.md",
|
||||
"eager-focus.md",
|
||||
"enable-autostart.md",
|
||||
"ensure-named-workspaces.md",
|
||||
"ensure-workspaces.md",
|
||||
"flip-layout.md",
|
||||
@@ -935,6 +1061,8 @@ fn docgen_writes_the_help_of_every_subcommand_in_a_text_fence() {
|
||||
"query.md",
|
||||
"quick-load-resize.md",
|
||||
"quick-save-resize.md",
|
||||
"quickstart.md",
|
||||
"replace-configuration.md",
|
||||
"resize-axis.md",
|
||||
"resize-delta.md",
|
||||
"resize-edge.md",
|
||||
|
||||
@@ -334,8 +334,14 @@ manage-rule exe nonexistent
|
||||
manage
|
||||
close
|
||||
retile
|
||||
replace-configuration /tmp/e2e-config.json
|
||||
eager-focus foot
|
||||
"""
|
||||
kde.sh(
|
||||
"printf %s "
|
||||
+ shlex.quote('{ "monitors": [ { "workspaces": [ { "name": "again", "layout": "BSP" } ] } ] }')
|
||||
+ " > /tmp/e2e-config.json"
|
||||
)
|
||||
for line in SWEEP.strip().splitlines():
|
||||
status, out = kde.run(shlex.join(["komorebic", *line.split()]))
|
||||
if status != 0:
|
||||
@@ -346,6 +352,12 @@ for line in SWEEP.strip().splitlines():
|
||||
continue
|
||||
checks.ok(f"komorebic {line}")
|
||||
|
||||
first_workspace = kde.state()["monitors"]["elements"][0]["workspaces"]["elements"][0]
|
||||
checks.check(
|
||||
"replace-configuration made the window manager again from the file",
|
||||
first_workspace["name"] == "again",
|
||||
)
|
||||
|
||||
print("== 3b. minimize, unmanage and manage the focused window")
|
||||
focused = kde.active()
|
||||
title = kde.title(focused)
|
||||
|
||||
@@ -4,7 +4,8 @@
|
||||
# opened in the session, that it runs with the module's log level, the `komorebi.json` the module
|
||||
# wrote from its `config`, and the PATH of the user's session, that systemd starts it again when
|
||||
# it is killed, and that a clean stop is not a failure. Once the unit is stopped, the daemon is
|
||||
# started with a `komorebi.json` of the user's, which it follows when the file changes. The
|
||||
# started with a `komorebi.json` of the user's, which it follows when the file changes, and
|
||||
# `komorebic enable-autostart` writes the entry systemd's autostart generator makes a unit of. The
|
||||
# options and the unit the module writes are checked without a machine by `nixos-module-eval`
|
||||
# (`nix/tests/nixos-module.nix`).
|
||||
import json
|
||||
@@ -188,4 +189,30 @@ checks.check(
|
||||
kde.komorebic("stop")
|
||||
checks.check("that daemon stops", kde.wait_for(lambda: not answering(), timeout=30))
|
||||
|
||||
print("== 6. an autostart entry is run by the session")
|
||||
ENTRY = "/home/komorebi/.config/autostart/komorebi.desktop"
|
||||
AUTOSTART = "app-komorebi@autostart.service"
|
||||
kde.komorebic("enable-autostart", "--config", MINE)
|
||||
checks.check(
|
||||
"komorebic enable-autostart writes the entry, with the file it is given",
|
||||
f'Exec=komorebi --config "{MINE}"' in machine.succeed(f"cat {ENTRY}"),
|
||||
)
|
||||
kde.systemctl("daemon-reload")
|
||||
status, unit_text = kde.run(f"systemctl --user cat {AUTOSTART}")
|
||||
print(unit_text)
|
||||
checks.check(
|
||||
"systemd's autostart generator makes a unit of it, which runs komorebi",
|
||||
status == 0 and "komorebi" in unit_text,
|
||||
)
|
||||
kde.systemctl("start", AUTOSTART)
|
||||
checks.check("... which starts a daemon that answers", kde.wait_for(answering, timeout=60))
|
||||
checks.check("... with the file the entry gave it", resize_delta() == 33)
|
||||
kde.komorebic("stop")
|
||||
checks.check("that daemon stops", kde.wait_for(lambda: not answering(), timeout=30))
|
||||
kde.komorebic("disable-autostart")
|
||||
checks.check(
|
||||
"komorebic disable-autostart takes the entry away",
|
||||
machine.execute(f"test -e {ENTRY}")[0] != 0,
|
||||
)
|
||||
|
||||
checks.finish()
|
||||
Reference in new issue
Block a user