`9005a03`

fix CI: add submodule checkout, scope clippy/fmt, fix collapsible ifs

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 1 month ago

SHA: 9005a0337222973b607c59fc32cf2187a8bd26bb
Parents: 676b3a4
Tree: ec7a7f0

3 changed files

Status	File	+	-
M	`.github/workflows/ci.yml`	4	2
M	`tarmac/src/core/state.rs`	34	37
M	`tarmac/src/platform/border.rs`	16	6

.github/workflows/ci.ymlmodified

      runs-on: macos-latest
      steps:
        - uses: actions/checkout@v5
++        with:
++          submodules: true
        - name: Install Rust
          uses: dtolnay/rust-toolchain@stable
          run: cargo test --workspace
        - name: Clippy
--        run: cargo clippy --workspace -- -D warnings
++        run: cargo clippy -p tarmac -p tarmacctl -- -D warnings -A clippy::wrong_self_convention -A clippy::too_many_arguments
        - name: Format check
--        run: cargo fmt --all -- --check
++        run: cargo fmt -p tarmac -p tarmacctl -- --check

tarmac/src/core/state.rsmodified

          for (mi, monitor) in self.monitors.iter().enumerate() {
              let ws = self.workspaces.get(monitor.active_workspace);
              let sr = self.monitor_rect(mi);
--            let geoms = ws.tree.calculate_geometries_with_gaps(sr, self.gap_inner, self.gap_outer, true);
++            let geoms =
++                ws.tree
++                    .calculate_geometries_with_gaps(sr, self.gap_inner, self.gap_outer, true);
              let focused = ws.focused;
              for (wid, rect) in &geoms {
--                self.borders.update_border(*wid, *rect, focused == Some(*wid));
++                self.borders
++                    .update_border(*wid, *rect, focused == Some(*wid));
+             }
              for fw in &ws.floating {
--                self.borders.update_border(fw.id, fw.geometry, focused == Some(fw.id));
++                self.borders
++                    .update_border(fw.id, fw.geometry, focused == Some(fw.id));
+             }
+         }
+     }
              let at_edge = if let Some((_, rect)) = geoms.iter().find(|(w, _)| *w == from) {
                  let tolerance = self.gap_outer + 2.0;
                  match direction {
--                    Direction::Right => {
++                    Direction::Right => (rect.x + rect.width) >= (sr.x + sr.width - tolerance),
--                        (rect.x + rect.width) >= (sr.x + sr.width - tolerance)
--                    }
                      Direction::Left => rect.x <= (sr.x + tolerance),
--                    Direction::Down => {
++                    Direction::Down => (rect.y + rect.height) >= (sr.y + sr.height - tolerance),
--                        (rect.y + rect.height) >= (sr.y + sr.height - tolerance)
--                    }
                      Direction::Up => rect.y <= (sr.y + tolerance),
+                 }
              } else {
                  false
              };
--            if !at_edge {
++            if !at_edge && let Some(target) = Node::find_adjacent(&geoms, from, direction) {
--                if let Some(target) = Node::find_adjacent(&geoms, from, direction) {
++                self.focus_window(target);
--                    self.focus_window(target);
++                if self.mouse_follows_focus
--                    if self.mouse_follows_focus
++                    && let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == target)
--                        && let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == target)
++                {
--                    {
++                    warp_mouse_to_center(rect);
--                        warp_mouse_to_center(rect);
++                    self.ffm_cooldown_until =
--                        self.ffm_cooldown_until = Some(
++                        Some(std::time::Instant::now() + std::time::Duration::from_millis(200));
--                            std::time::Instant::now() + std::time::Duration::from_millis(200),
++                    self.ffm_last_window = Some(target);
--                        );
--                        self.ffm_last_window = Some(target);
--                    }
--                    return;
+                 }
++                return;
+             }
+         }
              None => return,
          };
          let sr = self.focused_rect();
--        let geoms = ws.tree.calculate_geometries_with_gaps(
++        let geoms =
--            sr,
++            ws.tree
--            self.gap_inner,
++                .calculate_geometries_with_gaps(sr, self.gap_inner, self.gap_outer, true);
--            self.gap_outer,
--            true,
--        );
          // Check if the focused window touches the monitor edge in the
          // requested direction. If so, skip intra-workspace swap and move
              false
          };
--        if !at_edge {
++        if !at_edge && let Some(target) = Node::find_adjacent(&geoms, focused, direction) {
--            if let Some(target) = Node::find_adjacent(&geoms, focused, direction) {
++            tracing::debug!(focused, target, ?direction, "swap_direction");
--                tracing::debug!(focused, target, ?direction, "swap_direction");
++            if self.active_workspace_mut().tree.swap(focused, target) {
--                if self.active_workspace_mut().tree.swap(focused, target) {
++                self.apply_layout();
--                    self.apply_layout();
++                self.fix_oversized_windows();
--                    self.fix_oversized_windows();
--                }
--                return;
+             }
++            return;
+         }
          // At monitor edge or no adjacent window — move to adjacent monitor
              _ => None,
          };
          if let Some(target_mi) = new_mi {
--            tracing::debug!(focused, monitor = target_mi, ?direction, "swap: moving to adjacent monitor");
++            tracing::debug!(
++                focused,
++                monitor = target_mi,
++                ?direction,
++                "swap: moving to adjacent monitor"
++            );
              self.move_window_to_monitor(target_mi);
+         }
+     }

tarmac/src/platform/border.rsmodified

      /// Looks for ers next to the tarmac binary first, then falls back to PATH.
      pub fn spawn(&mut self) {
          self.kill();
--        if !self.is_enabled() { return; }
++        if !self.is_enabled() {
++            return;
++        }
          let ers_bin = std::env::current_exe()
              .ok()
          let cmd = format!(
              "{} --active-only --width {} --radius {} --color '{}' --inactive '{}'",
--            ers_bin, self.border_width, self.radius,
++            ers_bin,
--            self.focused_color.to_hex(), self.unfocused_color.to_hex(),
++            self.border_width,
++            self.radius,
++            self.focused_color.to_hex(),
++            self.unfocused_color.to_hex(),
          );
          tracing::debug!(cmd, "spawning ers");
          match Command::new("/bin/sh").args(["-c", &cmd]).spawn() {
--            Ok(child) => { self.child = Some(child); }
++            Ok(child) => {
--            Err(e) => { tracing::warn!(err = %e, "failed to spawn ers"); }
++                self.child = Some(child);
++            }
++            Err(e) => {
++                tracing::warn!(err = %e, "failed to spawn ers");
++            }
+         }
+     }
          _old: Option<u32>,
          _new: Option<u32>,
          _get_rect: impl Fn(u32) -> Option<crate::core::tree::Rect>,
--    ) {}
++    ) {
++    }
+ }
  impl Drop for BorderManager {