From 7b3f691194f9ad6f3398ec3dca498c2558a510ab Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 18:36:22 -0700 Subject: [PATCH] feat(core): the first shared commands, over a CommandHost, with native tests komorebi-core gets `command`: the workspace navigation commands as functions generic over a CommandHost (the few window-manager operations they build on: the monitors and the focused one, the monitor under the pointer, focus_monitor, focus_workspace, move_container_to_workspace): cycle_focus_workspace, cycle_focus_empty_workspace, close_workspace, focus_last_workspace and move_container_to_last_workspace. The text is KDE's (which is macOS's); the one platform difference, that Windows lets the pointer pick the monitor first for cycle_focus_empty_workspace, close_workspace and focus_last_workspace where KDE and macOS do not, is the associated const CommandHost::POINTER_PICKS_THE_MONITOR_FOR_ALL (false by default). Nothing uses them yet. tests/commands.rs implements the host with a recording stub and mirrors the e2e checks of commands.py (cycle-workspace, cycle-empty-workspace, close-workspace, focus-last-workspace, move-to-last-workspace and send-to-last-workspace): wrap-around, the pointer's monitor, which workspaces close, going back and forth, follow and send, and the Windows switch. Verified: cargo test -p komorebi-core --features schemars (native): 30 unit + 9 command tests passed, 0 failed (and the other test files of the crate). Not run: the daemons (nothing calls the functions yet). --- crates/komorebi-core/src/command.rs | 220 +++++++++++++++++++ crates/komorebi-core/src/lib.rs | 2 + crates/komorebi-core/tests/commands.rs | 289 +++++++++++++++++++++++++ 3 files changed, 511 insertions(+) create mode 100644 crates/komorebi-core/src/command.rs create mode 100644 crates/komorebi-core/tests/commands.rs diff --git a/crates/komorebi-core/src/command.rs b/crates/komorebi-core/src/command.rs new file mode 100644 index 00000000..33081d6b --- /dev/null +++ b/crates/komorebi-core/src/command.rs @@ -0,0 +1,220 @@ +//! The commands that only move the focus and the containers around the shared model. +//! +//! A daemon's `process_command` is a router over its `WindowManager`, which is per platform. What a +//! command does to the monitors, workspaces and containers does not depend on the platform, so the +//! commands whose work is only that are functions here, generic over a [`CommandHost`]: the few +//! operations of the window manager they build on (focus a monitor, show a workspace, move a +//! container). Each daemon implements the host with its own window manager, and the arm of its router +//! calls the function; a test implements it with a recording stub and checks the calls, which is how a +//! command's logic is tested without a Windows or macOS machine. + +use crate::Monitor; +use crate::MonitorPlatform; +use color_eyre::eyre; +use color_eyre::eyre::OptionExt; +use komorebi_layouts::CycleDirection; +use komorebi_layouts::OperationDirection; +use std::collections::VecDeque; +use std::num::NonZeroUsize; + +/// The window manager as the shared commands see it. +pub trait CommandHost { + /// The platform whose monitors the host has. + type P: MonitorPlatform; + + /// Whether the commands that act on the focused monitor first focus the monitor the pointer is + /// on when the workspace shown there is empty, for `cycle_focus_empty_workspace`, + /// `close_workspace` and `focus_last_workspace` (the other commands always do). Windows does it + /// for all of them; KDE and macOS do not. + const POINTER_PICKS_THE_MONITOR_FOR_ALL: bool = false; + + /// The monitors. + fn monitors(&self) -> &VecDeque>; + + /// The monitor that has the focus, if there is one. + fn focused_monitor(&self) -> Option<&Monitor>; + + /// The monitor that has the focus, mutably. + fn focused_monitor_mut(&mut self) -> Option<&mut Monitor>; + + /// The index of the monitor that has the focus. + fn focused_monitor_idx(&self) -> usize; + + /// The index of the monitor the pointer is on, if the platform says where it is. + fn monitor_idx_from_current_pos(&mut self) -> Option; + + /// Gives the focus to the monitor at `idx`. + fn focus_monitor(&mut self, idx: usize) -> eyre::Result<()>; + + /// Shows workspace `idx` on the focused monitor and focuses it. + fn focus_workspace(&mut self, idx: usize) -> eyre::Result<()>; + + /// Moves the focused container to workspace `idx` of the focused monitor. + fn move_container_to_workspace( + &mut self, + idx: usize, + follow: bool, + direction: Option, + ) -> eyre::Result<()>; +} + +/// This is to ensure that even on an empty workspace on a secondary monitor, the secondary monitor +/// where the cursor is focused will be used as the target for the workspace switch op +fn focus_the_monitor_under_the_pointer(host: &mut H) -> eyre::Result<()> { + if let Some(monitor_idx) = host.monitor_idx_from_current_pos() + && monitor_idx != host.focused_monitor_idx() + && let Some(monitor) = host.monitors().get(monitor_idx) + && let Some(workspace) = monitor.focused_workspace() + && workspace.is_empty() + { + host.focus_monitor(monitor_idx)?; + } + + Ok(()) +} + +/// Focuses the next or previous workspace of the monitor that is focused, or of the monitor the +/// pointer is on when its workspace is empty +pub fn cycle_focus_workspace( + host: &mut H, + direction: CycleDirection, +) -> eyre::Result<()> { + focus_the_monitor_under_the_pointer(host)?; + + let focused_monitor = host.focused_monitor().ok_or_eyre("there is no monitor")?; + + let focused_workspace_idx = focused_monitor.focused_workspace_idx(); + let workspaces = focused_monitor.workspaces().len(); + + let workspace_idx = direction.next_idx( + focused_workspace_idx, + NonZeroUsize::new(workspaces).ok_or_eyre("there must be at least one workspace")?, + ); + + host.focus_workspace(workspace_idx)?; + Ok(()) +} + +/// Focuses the next or previous empty workspace of the focused monitor, if it has one +pub fn cycle_focus_empty_workspace( + host: &mut H, + direction: CycleDirection, +) -> eyre::Result<()> { + if H::POINTER_PICKS_THE_MONITOR_FOR_ALL { + focus_the_monitor_under_the_pointer(host)?; + } + + let focused_monitor = host.focused_monitor().ok_or_eyre("there is no monitor")?; + + let focused_workspace_idx = focused_monitor.focused_workspace_idx(); + let workspaces = focused_monitor.workspaces().len(); + + let mut empty_workspaces = vec![]; + + for (idx, w) in focused_monitor.workspaces().iter().enumerate() { + if w.is_empty() { + empty_workspaces.push(idx); + } + } + + if !empty_workspaces.is_empty() { + let mut workspace_idx = direction.next_idx( + focused_workspace_idx, + NonZeroUsize::new(workspaces).ok_or_eyre("there must be at least one workspace")?, + ); + + while !empty_workspaces.contains(&workspace_idx) { + workspace_idx = direction.next_idx( + workspace_idx, + NonZeroUsize::new(workspaces).ok_or_eyre("there must be at least one workspace")?, + ); + } + + host.focus_workspace(workspace_idx)?; + } + Ok(()) +} + +/// Removes the focused workspace when it is empty, unnamed and not the monitor's only one, and +/// focuses the one before it +pub fn close_workspace(host: &mut H) -> eyre::Result<()> { + if H::POINTER_PICKS_THE_MONITOR_FOR_ALL { + focus_the_monitor_under_the_pointer(host)?; + } + + let mut can_close = false; + + if let Some(monitor) = host.focused_monitor_mut() { + let focused_workspace_idx = monitor.focused_workspace_idx(); + let next_focused_workspace_idx = focused_workspace_idx.saturating_sub(1); + + if let Some(workspace) = monitor.focused_workspace() + && monitor.workspaces().len() > 1 + && workspace.containers().is_empty() + && workspace.floating_windows().is_empty() + && workspace.monocle_container.is_none() + && workspace.maximized_window.is_none() + && workspace.name.is_none() + { + can_close = true; + } + + if can_close + && monitor + .workspaces_mut() + .remove(focused_workspace_idx) + .is_some() + { + host.focus_workspace(next_focused_workspace_idx)?; + } + } + Ok(()) +} + +/// Focuses the workspace that was focused before this one +pub fn focus_last_workspace(host: &mut H) -> eyre::Result<()> { + if H::POINTER_PICKS_THE_MONITOR_FOR_ALL { + focus_the_monitor_under_the_pointer(host)?; + } + + let idx = host + .focused_monitor() + .ok_or_eyre("there is no monitor")? + .focused_workspace_idx(); + + if let Some(monitor) = host.focused_monitor_mut() + && let Some(last_focused_workspace) = monitor.last_focused_workspace + { + host.focus_workspace(last_focused_workspace)?; + } + + host.focused_monitor_mut() + .ok_or_eyre("there is no monitor")? + .last_focused_workspace = Option::from(idx); + Ok(()) +} + +/// Moves the focused container to the workspace that was focused before this one, and follows it +/// when `follow` is set +pub fn move_container_to_last_workspace( + host: &mut H, + follow: bool, +) -> eyre::Result<()> { + focus_the_monitor_under_the_pointer(host)?; + + let idx = host + .focused_monitor() + .ok_or_eyre("there is no monitor")? + .focused_workspace_idx(); + + if let Some(monitor) = host.focused_monitor_mut() + && let Some(last_focused_workspace) = monitor.last_focused_workspace + { + host.move_container_to_workspace(last_focused_workspace, follow, None)?; + } + + host.focused_monitor_mut() + .ok_or_eyre("there is no monitor")? + .last_focused_workspace = Option::from(idx); + Ok(()) +} diff --git a/crates/komorebi-core/src/lib.rs b/crates/komorebi-core/src/lib.rs index 4d39431d..3aceffad 100644 --- a/crates/komorebi-core/src/lib.rs +++ b/crates/komorebi-core/src/lib.rs @@ -7,6 +7,7 @@ #![deny(missing_docs)] +mod command; mod container; mod globals; #[allow(missing_docs)] @@ -14,6 +15,7 @@ mod monitor; #[allow(missing_docs)] mod workspace; +pub use command::*; pub use container::Container; pub use container::ContainerWindow; pub use container::WorkspaceWindow; diff --git a/crates/komorebi-core/tests/commands.rs b/crates/komorebi-core/tests/commands.rs new file mode 100644 index 00000000..a9781f03 --- /dev/null +++ b/crates/komorebi-core/tests/commands.rs @@ -0,0 +1,289 @@ +//! The shared commands of `komorebi_core::command`, on a recording host. +//! +//! Each test names the e2e check of `commands.py` (SWEEP) it mirrors: the e2e sends the command to a +//! running daemon and checks that it is answered and the daemon survives; here the effect on the +//! model is checked, for all three daemons at once. + +mod common; + +use color_eyre::eyre; +use common::*; +use komorebi_core::CommandHost; +use komorebi_core::Monitor; +use komorebi_layouts::CycleDirection; +use komorebi_layouts::OperationDirection; +use std::collections::VecDeque; + +struct Host { + monitors: VecDeque>, + focused: usize, + pointer_on: Option, + calls: Vec, + pointer_for_all: bool, +} + +fn monitor(workspaces: usize) -> Monitor { + let mut monitor: Monitor = serde_json::from_value(serde_json::json!({ + "id": 7, + "device": "Virtual-0", + "size": { "left": 0, "top": 0, "right": 1920, "bottom": 1080 }, + "work_area_size": { "left": 0, "top": 0, "right": 1920, "bottom": 1040 }, + "work_area_offset": null, + "window_based_work_area_offset": null, + "window_based_work_area_offset_limit": 1, + "workspaces": { "elements": [], "focused": 0 }, + "container_padding": null, + "workspace_padding": null, + "wallpaper": null, + "floating_layer_behaviour": null + })) + .unwrap(); + monitor.ensure_workspace_count(workspaces); + monitor +} + +impl Host { + fn new(workspaces: usize) -> Self { + fresh(); + Self { + monitors: VecDeque::from([monitor(workspaces)]), + focused: 0, + pointer_on: None, + calls: vec![], + pointer_for_all: false, + } + } + + fn shown(&self) -> usize { + self.monitors[self.focused].focused_workspace_idx() + } + + /// puts a window on workspace `idx` of the focused monitor + fn occupy(&mut self, idx: usize, window: u32) { + self.monitors[self.focused].workspaces_mut()[idx] + .new_container_for_window(StubWindow { id: window }); + } +} + +impl CommandHost for Host { + type P = StubPlatform; + + fn monitors(&self) -> &VecDeque> { + &self.monitors + } + + fn focused_monitor(&self) -> Option<&Monitor> { + self.monitors.get(self.focused) + } + + fn focused_monitor_mut(&mut self) -> Option<&mut Monitor> { + self.monitors.get_mut(self.focused) + } + + fn focused_monitor_idx(&self) -> usize { + self.focused + } + + fn monitor_idx_from_current_pos(&mut self) -> Option { + self.pointer_on + } + + fn focus_monitor(&mut self, idx: usize) -> eyre::Result<()> { + self.calls.push(format!("focus_monitor {idx}")); + self.focused = idx; + Ok(()) + } + + fn focus_workspace(&mut self, idx: usize) -> eyre::Result<()> { + self.calls.push(format!("focus_workspace {idx}")); + self.monitors[self.focused].focus_workspace(idx) + } + + fn move_container_to_workspace( + &mut self, + idx: usize, + follow: bool, + _: Option, + ) -> eyre::Result<()> { + self.calls.push(format!("move_container {idx} {follow}")); + Ok(()) + } +} + +#[test] +fn cycle_workspace_next_and_previous_wrap_around() { + // commands.py: "cycle-workspace next" / "cycle-workspace previous" + let mut host = Host::new(3); + + komorebi_core::cycle_focus_workspace(&mut host, CycleDirection::Next).unwrap(); + assert_eq!(host.shown(), 1); + komorebi_core::cycle_focus_workspace(&mut host, CycleDirection::Next).unwrap(); + komorebi_core::cycle_focus_workspace(&mut host, CycleDirection::Next).unwrap(); + assert_eq!( + host.shown(), + 0, + "next wraps from the last workspace to the first" + ); + + komorebi_core::cycle_focus_workspace(&mut host, CycleDirection::Previous).unwrap(); + assert_eq!(host.shown(), 2, "previous wraps from the first to the last"); +} + +#[test] +fn cycling_focuses_the_monitor_under_the_pointer_when_its_workspace_is_empty() { + // the preamble of cycle-workspace on a second monitor + let mut host = Host::new(2); + host.monitors.push_back(monitor(2)); + host.pointer_on = Some(1); + + komorebi_core::cycle_focus_workspace(&mut host, CycleDirection::Next).unwrap(); + + assert_eq!(host.calls[0], "focus_monitor 1"); + assert_eq!(host.focused, 1); +} + +#[test] +fn cycle_empty_workspace_skips_the_ones_with_windows() { + // commands.py: "cycle-empty-workspace next" + let mut host = Host::new(4); + host.occupy(0, 1); + host.occupy(1, 2); + + komorebi_core::cycle_focus_empty_workspace(&mut host, CycleDirection::Next).unwrap(); + + assert_eq!(host.shown(), 2); +} + +#[test] +fn cycle_empty_workspace_does_nothing_when_none_is_empty() { + let mut host = Host::new(2); + host.occupy(0, 1); + host.occupy(1, 2); + + komorebi_core::cycle_focus_empty_workspace(&mut host, CycleDirection::Next).unwrap(); + + assert!(host.calls.is_empty()); +} + +#[test] +fn close_workspace_removes_an_empty_unnamed_one_and_focuses_the_one_before() { + // commands.py: "close-workspace" + let mut host = Host::new(3); + host.monitors[0].focus_workspace(2).unwrap(); + + komorebi_core::close_workspace(&mut host).unwrap(); + + assert_eq!(host.monitors[0].workspaces().len(), 2); + assert_eq!(host.calls, ["focus_workspace 1"]); +} + +#[test] +fn close_workspace_keeps_a_workspace_with_a_window_a_name_or_the_only_one() { + let mut host = Host::new(2); + host.monitors[0].focus_workspace(1).unwrap(); + host.occupy(1, 1); + komorebi_core::close_workspace(&mut host).unwrap(); + assert_eq!(host.monitors[0].workspaces().len(), 2, "a window keeps it"); + + let mut host = Host::new(2); + host.monitors[0].focus_workspace(1).unwrap(); + host.monitors[0].workspaces_mut()[1].name = Some("web".to_string()); + komorebi_core::close_workspace(&mut host).unwrap(); + assert_eq!(host.monitors[0].workspaces().len(), 2, "a name keeps it"); + + let mut host = Host::new(1); + komorebi_core::close_workspace(&mut host).unwrap(); + assert_eq!(host.monitors[0].workspaces().len(), 1, "the only one stays"); +} + +#[test] +fn focus_last_workspace_goes_back_and_forth() { + // commands.py: "focus-last-workspace" twice + let mut host = Host::new(3); + host.monitors[0].focus_workspace(2).unwrap(); + + komorebi_core::focus_last_workspace(&mut host).unwrap(); + assert_eq!(host.shown(), 0, "the workspace shown before this one"); + + komorebi_core::focus_last_workspace(&mut host).unwrap(); + assert_eq!(host.shown(), 2, "and back again"); +} + +#[test] +fn move_to_last_workspace_moves_the_container_and_remembers_where_it_came_from() { + // commands.py: "move-to-last-workspace" and "send-to-last-workspace" + let mut host = Host::new(3); + host.monitors[0].focus_workspace(2).unwrap(); + + komorebi_core::move_container_to_last_workspace(&mut host, true).unwrap(); + assert_eq!(host.calls, ["move_container 0 true"]); + assert_eq!(host.monitors[0].last_focused_workspace, Some(2)); + + host.calls.clear(); + komorebi_core::move_container_to_last_workspace(&mut host, false).unwrap(); + assert_eq!( + host.calls, + ["move_container 2 false"], + "send does not follow" + ); +} + +#[test] +fn only_windows_lets_the_pointer_pick_the_monitor_for_the_empty_and_close_commands() { + // the platform switch of CommandHost::POINTER_PICKS_THE_MONITOR_FOR_ALL (default false: KDE and + // macOS); a host that says true gets the preamble for close and cycle-empty too + struct WindowsLike(Host); + + impl CommandHost for WindowsLike { + type P = StubPlatform; + const POINTER_PICKS_THE_MONITOR_FOR_ALL: bool = true; + + fn monitors(&self) -> &VecDeque> { + self.0.monitors() + } + fn focused_monitor(&self) -> Option<&Monitor> { + self.0.focused_monitor() + } + fn focused_monitor_mut(&mut self) -> Option<&mut Monitor> { + self.0.focused_monitor_mut() + } + fn focused_monitor_idx(&self) -> usize { + self.0.focused_monitor_idx() + } + fn monitor_idx_from_current_pos(&mut self) -> Option { + self.0.monitor_idx_from_current_pos() + } + fn focus_monitor(&mut self, idx: usize) -> eyre::Result<()> { + self.0.focus_monitor(idx) + } + fn focus_workspace(&mut self, idx: usize) -> eyre::Result<()> { + self.0.focus_workspace(idx) + } + fn move_container_to_workspace( + &mut self, + idx: usize, + follow: bool, + direction: Option, + ) -> eyre::Result<()> { + self.0.move_container_to_workspace(idx, follow, direction) + } + } + + let mut other = Host::new(2); + other.monitors.push_back(monitor(2)); + other.pointer_on = Some(1); + komorebi_core::close_workspace(&mut other).unwrap(); + assert!( + !other.calls.iter().any(|call| call.starts_with("focus_monitor")), + "KDE and macOS do not look at the pointer here" + ); + + let mut host = WindowsLike({ + let mut host = Host::new(2); + host.monitors.push_back(monitor(2)); + host.pointer_on = Some(1); + host + }); + komorebi_core::close_workspace(&mut host).unwrap(); + assert_eq!(host.0.calls[0], "focus_monitor 1"); +}