refactor: clippy fixes and working doctests (#834)

Author: Miitto

packages/watcher/src/main.rs

@@ -35,7 +35,7 @@ async fn main() -> anyhow::Result<()> {
 
       let managed_windows = managed_handles
         .into_iter()
-        .map(|handle| NativeWindow::new(handle))
+        .map(NativeWindow::new)
         .collect::<Vec<_>>();
 
       run_cleanup(managed_windows);
@@ -56,7 +56,7 @@ async fn query_initial_windows(
     .context("Failed to send window query command.")?;
 
   client
-    .client_response(&query_message)
+    .client_response(query_message)
     .await
     .and_then(|response| match response.data {
       Some(ClientResponseData::Windows(data)) => Some(data),
@@ -83,12 +83,12 @@ async fn watch_managed_handles(
     "sub -e window_managed window_unmanaged application_exiting";
 
   client
-    .send(&subscription_message)
+    .send(subscription_message)
     .await
     .context("Failed to send subscribe command to IPC server.")?;
 
   let subscription_id = client
-    .client_response(&subscription_message)
+    .client_response(subscription_message)
     .await
     .and_then(|response| match response.data {
       Some(ClientResponseData::EventSubscribe(data)) => {

packages/wm/src/app_command.rs

@@ -38,7 +38,7 @@ use crate::{
   },
 };
 
-const VERSION: &'static str = env!("VERSION_NUMBER");
+const VERSION: &str = env!("VERSION_NUMBER");
 
 #[derive(Clone, Debug, Parser)]
 #[clap(author, version = VERSION, about, long_about = None)]
@@ -522,11 +522,7 @@ impl InvokeCommand {
         match subject_container.as_window_container() {
           Ok(window) => {
             _ = window.native().set_title_bar_visibility(
-              if *visibility == TitleBarVisibility::Shown {
-                true
-              } else {
-                false
-              },
+              *visibility == TitleBarVisibility::Shown,
             );
             Ok(())
           }
@@ -536,7 +532,7 @@ impl InvokeCommand {
       InvokeCommand::ShellExec {
         hide_window,
         command,
-      } => shell_exec(&command.join(" "), hide_window.clone()),
+      } => shell_exec(&command.join(" "), *hide_window),
       InvokeCommand::Size(args) => {
         match subject_container.as_window_container() {
           Ok(window) => set_window_size(

packages/wm/src/common/commands/cycle_focus.rs

@@ -46,12 +46,14 @@ pub fn cycle_focus(
       let window_of_type = workspace
         .descendant_focus_order()
         .filter_map(|descendant| descendant.as_window_container().ok())
-        .find(|descendant| match (descendant.state(), &next) {
-          (WindowState::Floating(_), WindowState::Floating(_)) => true,
-          (WindowState::Fullscreen(_), WindowState::Fullscreen(_)) => true,
-          (WindowState::Minimized, WindowState::Minimized) => true,
-          (WindowState::Tiling, WindowState::Tiling) => true,
-          _ => false,
+        .find(|descendant| {
+          matches!(
+            (descendant.state(), &next),
+            (WindowState::Floating(_), WindowState::Floating(_))
+              | (WindowState::Fullscreen(_), WindowState::Fullscreen(_))
+              | (WindowState::Minimized, WindowState::Minimized)
+              | (WindowState::Tiling, WindowState::Tiling)
+          )
         });
 
       if let Some(window) = window_of_type {

packages/wm/src/common/commands/platform_sync.rs

@@ -22,7 +22,7 @@ pub fn platform_sync(
   state: &mut WmState,
   config: &UserConfig,
 ) -> anyhow::Result<()> {
-  if state.pending_sync.containers_to_redraw.len() > 0 {
+  if !state.pending_sync.containers_to_redraw.is_empty() {
     redraw_containers(state)?;
     state.pending_sync.containers_to_redraw.clear();
   }
@@ -129,10 +129,10 @@ fn redraw_containers(state: &mut WmState) -> anyhow::Result<()> {
       .to_rect()?
       .apply_delta(&window.total_border_delta()?, None);
 
-    let is_visible = match window.display_state() {
-      DisplayState::Showing | DisplayState::Shown => true,
-      _ => false,
-    };
+    let is_visible = matches!(
+      window.display_state(),
+      DisplayState::Showing | DisplayState::Shown
+    );
 
     if let Err(err) = window.native().set_position(
       &window.state(),

packages/wm/src/common/commands/reload_config.rs

@@ -119,7 +119,6 @@ fn update_container_gaps(state: &mut WmState, config: &UserConfig) {
   let tiling_containers = state
     .root_container
     .self_and_descendants()
-    .into_iter()
     .filter_map(|container| container.as_tiling_container().ok());
 
   for container in tiling_containers {

packages/wm/src/common/direction.rs

@@ -17,7 +17,9 @@ impl Direction {
   ///
   /// Example:
   /// ```
-  /// Direction::Left.inverse() // Direction::Right
+  /// # use wm::common::Direction;
+  /// let dir = Direction::Left.inverse();
+  /// assert_eq!(dir, Direction::Right);
   /// ```
   pub fn inverse(&self) -> Direction {
     match self {
@@ -36,7 +38,10 @@ impl FromStr for Direction {
   ///
   /// Example:
   /// ```
-  /// Direction::from_str("left") // Direction::Left
+  /// # use wm::common::Direction;
+  /// # use std::str::FromStr;
+  /// let dir = Direction::from_str("left");
+  /// assert_eq!(dir.unwrap(), Direction::Left);
   /// ```
   fn from_str(unparsed: &str) -> anyhow::Result<Self> {
     match unparsed {

packages/wm/src/common/events/handle_display_settings_changed.rs

@@ -85,7 +85,7 @@ pub fn handle_display_settings_changed(
   }
 
   for native_monitor in new_native_monitors {
-    match pending_monitors.get(0) {
+    match pending_monitors.first() {
       Some(_) => {
         let monitor = pending_monitors.remove(0);
         update_monitor(monitor, native_monitor, state)

packages/wm/src/common/events/handle_window_location_changed.rs

@@ -63,7 +63,7 @@ pub fn handle_window_location_changed(
         // A fullscreen window that gets minimized can hit this arm, so
         // ignore such events and let it be handled by the handler for
         // `PlatformEvent::WindowMinimized` instead.
-        if !(is_fullscreen || is_maximized) && !is_minimized {
+        if !(is_fullscreen || is_maximized || !is_minimized) {
           info!("Window restored");
 
           let target_state = window

packages/wm/src/common/events/handle_window_minimized.rs

@@ -34,8 +34,7 @@ pub fn handle_window_minimized(
       )?;
 
       // Focus should be reassigned after a window has been minimized.
-      if let Some(focus_target) =
-        state.focus_target_after_removal(&window.into())
+      if let Some(focus_target) = state.focus_target_after_removal(&window)
       {
         set_focused_descendant(focus_target, None);
         state.pending_sync.focus_change = true;

packages/wm/src/common/length_value.rs

@@ -50,7 +50,14 @@ impl FromStr for LengthValue {
   ///
   /// Example:
   /// ```
-  /// LengthValue::from_str("100px") // { amount: 100.0, unit: LengthUnit::Pixel }
+  /// # use wm::common::{LengthValue, LengthUnit};
+  /// # use std::str::FromStr;
+  /// let check = LengthValue {
+  ///   amount: 100.0,
+  ///   unit: LengthUnit::Pixel,
+  /// };
+  /// let parsed = LengthValue::from_str("100px");
+  /// assert_eq!(parsed.unwrap(), check);
   /// ```
   fn from_str(unparsed: &str) -> anyhow::Result<Self> {
     let units_regex = Regex::new(r"([+-]?\d+)(%|px)?")?;

packages/wm/src/common/memo.rs

@@ -10,16 +10,25 @@ where
   value: Arc<Mutex<Option<T>>>,
 }
 
-impl<T> Memo<T>
+impl<T> Default for Memo<T>
 where
   T: Clone,
 {
-  /// Creates a new `Memo` instance with `None` as the initial value.
-  pub fn new() -> Self {
+  fn default() -> Self {
     Memo {
       value: Arc::new(Mutex::new(None)),
     }
   }
+}
+
+impl<T> Memo<T>
+where
+  T: Clone,
+{
+  /// Creates a new `Memo` instance with `None` as the initial value.
+  pub fn new() -> Self {
+    Self::default()
+  }
 
   /// Retrieves the cached value if it exists, otherwise initializes it
   /// using the provided closure.
@@ -38,7 +47,7 @@ where
       .as_ref()
       .map(|value| Ok(value.clone()))
       .unwrap_or_else(|| {
-        let value = retriever_fn(&arg)?;
+        let value = retriever_fn(arg)?;
         *value_ref = Some(value.clone());
         Ok(value)
       })
@@ -53,7 +62,7 @@ where
   {
     let mut value_ref = self.value.lock().unwrap();
 
-    let value = retriever_fn(&arg)?;
+    let value = retriever_fn(arg)?;
     *value_ref = Some(value.clone());
     Ok(value)
   }

packages/wm/src/common/platform/event_listener.rs

@@ -62,7 +62,7 @@ impl EventListener {
   pub fn update(
     &mut self,
     config: &UserConfig,
-    binding_modes: &Vec<BindingModeConfig>,
+    binding_modes: &[BindingModeConfig],
   ) {
     // Modify keybindings based on active binding modes.
     let keybindings = match binding_modes.first() {

packages/wm/src/common/platform/keyboard_hook.rs

@@ -121,11 +121,11 @@ impl KeyboardHook {
           .collect::<Vec<_>>();
 
         // Safety: A split string always has at least one element.
-        let trigger_key = vk_codes.last().unwrap().clone();
+        let trigger_key = *vk_codes.last().unwrap();
 
         keybinding_map
           .entry(trigger_key)
-          .or_insert_with(|| Vec::new())
+          .or_insert_with(Vec::new)
           .push(ActiveKeybinding {
             vk_codes,
             config: keybinding.clone(),

packages/wm/src/common/platform/native_monitor.rs

@@ -88,9 +88,10 @@ impl NativeMonitor {
       // Get the display devices associated with the monitor.
       let mut display_devices = (0..)
         .map_while(|index| {
-          let mut display_device = DISPLAY_DEVICEW::default();
-          display_device.cb =
-            std::mem::size_of::<DISPLAY_DEVICEW>() as u32;
+          let mut display_device = DISPLAY_DEVICEW {
+            cb: std::mem::size_of::<DISPLAY_DEVICEW>() as u32,
+            ..Default::default()
+          };
 
           // Due to the `EDD_GET_DEVICE_INTERFACE_NAME` flag, the device
           // struct will contain the DOS device path under the `DeviceId`
@@ -104,7 +105,7 @@ impl NativeMonitor {
             )
           }
           .as_bool()
-          .then(|| display_device)
+          .then_some(display_device)
         })
         // Filter out any devices that are not active.
         .filter(|device| device.StateFlags & DISPLAY_DEVICE_ACTIVE != 0);
@@ -173,7 +174,7 @@ pub fn available_monitors() -> anyhow::Result<Vec<NativeMonitor>> {
   Ok(
     available_monitor_handles()?
       .into_iter()
-      .map(|handle| NativeMonitor::new(handle))
+      .map(NativeMonitor::new)
       .collect(),
   )
 }

packages/wm/src/common/platform/platform.rs

@@ -337,16 +337,18 @@ impl Platform {
   ///
   /// # Examples
   ///
-  /// ```
-  /// let (prog, args) = parse_command("code .")?;
-  /// assert_eq!(prog, "code");
-  /// assert_eq!(args, ".");
+  /// ```no_run
+  /// # use wm::common::platform::Platform;
+  ///   let (prog, args) = Platform::parse_command("code .")?;
+  ///   assert_eq!(prog, "code");
+  ///   assert_eq!(args, ".");
   ///
-  /// let (prog, args) = parse_command(
-  ///   r#"C:\Program Files\Git\git-bash --cd=C:\Users\larsb\.glaze-wm"#,
-  /// )?;
-  /// assert_eq!(prog, r#"C:\Program Files\Git\git-bash"#);
-  /// assert_eq!(args, r#"--cd=C:\Users\larsb\.glaze-wm"#);
+  ///   let (prog, args) = Platform::parse_command(
+  ///     r#"C:\Program Files\Git\git-bash --cd=C:\Users\larsb\.glaze-wm"#,
+  ///   )?;
+  ///   assert_eq!(prog, r#"C:\Program Files\Git\git-bash"#);
+  ///   assert_eq!(args, r#"--cd=C:\Users\larsb\.glaze-wm"#);
+  /// # Ok::<(), anyhow::Error>(())
   /// ```
   pub fn parse_command(command: &str) -> anyhow::Result<(String, String)> {
     // Expand environment variables in the command string.
@@ -376,7 +378,7 @@ impl Platform {
     };
 
     let command_parts: Vec<&str> =
-      expanded_command.trim().split_whitespace().collect();
+      expanded_command.split_whitespace().collect();
 
     // If the command starts with double quotes, then the program name/path
     // is wrapped in double quotes (e.g. `"C:\path\to\app.exe" --flag`).
@@ -435,8 +437,8 @@ impl Platform {
     // causes issues where the pointer is dropped while `ShellExecuteExW`
     // is using it. This is likely a `windows-rs` bug, and we can avoid
     // it by keeping separate variables for the wide strings.
-    let program_wide = to_wide(&program);
-    let args_wide = to_wide(&args);
+    let program_wide = to_wide(program);
+    let args_wide = to_wide(args);
     let home_dir_wide = to_wide(&home_dir);
 
     // Using the built-in `Command::new` function in Rust launches the

packages/wm/src/common/tiling_direction.rs

@@ -17,7 +17,9 @@ impl TilingDirection {
   ///
   /// Example:
   /// ```
-  /// TilingDirection::Horizontal.inverse() // TilingDirection::Vertical
+  /// # use wm::common::TilingDirection;
+  /// let dir = TilingDirection::Horizontal.inverse();
+  /// assert_eq!(dir, TilingDirection::Vertical);
   /// ```
   pub fn inverse(&self) -> TilingDirection {
     match self {
@@ -31,7 +33,9 @@ impl TilingDirection {
   ///
   /// Example:
   /// ```
-  /// TilingDirection::from_direction(Direction::Left) // TilingDirection::Horizontal
+  /// # use wm::common::{Direction, TilingDirection};
+  /// let dir = TilingDirection::from_direction(&Direction::Left);
+  /// assert_eq!(dir, TilingDirection::Horizontal);
   /// ```
   pub fn from_direction(direction: &Direction) -> TilingDirection {
     match direction {
@@ -48,7 +52,13 @@ impl FromStr for TilingDirection {
   ///
   /// Example:
   /// ```
-  /// TilingDirection::from_str("horizontal") // TilingDirection::Horizontal
+  /// # use wm::common::TilingDirection;
+  /// # use std::str::FromStr;
+  /// let dir = TilingDirection::from_str("horizontal");
+  /// assert_eq!(dir.unwrap(), TilingDirection::Horizontal);
+  ///
+  /// let dir = TilingDirection::from_str("vertical");
+  /// assert_eq!(dir.unwrap(), TilingDirection::Vertical);
   /// ```
   fn from_str(unparsed: &str) -> anyhow::Result<Self> {
     match unparsed {

packages/wm/src/containers/commands/flatten_child_split_containers.rs

@@ -8,7 +8,7 @@ use crate::containers::{
 /// parent container.
 ///
 /// For example:
-/// ```
+/// ```ignore,compile_fail
 /// H[1 H[V[2, 3]]] -> H[1, 2, 3]
 /// H[1 H[2, 3]] -> H[1, 2, 3]
 /// H[V[1]] -> V[1]

packages/wm/src/containers/commands/flatten_split_container.rs

@@ -17,7 +17,7 @@ pub fn flatten_split_container(
   let parent = split_container.parent().context("No parent.")?;
 
   let updated_children =
-    split_container.children().into_iter().map(|child| {
+    split_container.children().into_iter().inspect(|child| {
       *child.borrow_parent_mut() = Some(parent.clone());
 
       // Resize tiling children to fit the size of the split container.
@@ -26,8 +26,6 @@ pub fn flatten_split_container(
           split_container.tiling_size() * tiling_child.tiling_size(),
         );
       }
-
-      child
     });
 
   let index = split_container.index();