fix: clippy warnings

.github/workflows/ci.yml

@@ -9,76 +9,30 @@ env:
   RUSTFLAGS: --deny warnings
   RUSTDOCFLAGS: --deny warnings
 jobs:
-  # Run tests.
+  build-and-test:
-  test:
-    name: Tests
     runs-on: ubuntu-latest
-    timeout-minutes: 30
+    env:
+      SCCACHE_GHA_ENABLED: "true"
+      RUSTC_WRAPPER: "sccache"
     steps:
-      - name: Checkout repository
+      - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
-      - name: Install Rust toolchain
+      - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
-      - name: Install dependencies
-        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
-      - name: Populate target directory from cache
-        uses: Leafwing-Studios/cargo-cache@v2
         with:
-          sweep-cache: true
+          toolchain: stable
-      - name: Run tests
+          components: clippy, rustfmt
+      - name: Run sccache-cache
+        uses: mozilla-actions/sccache-action@v0.0.9
+      - name: Install cargo-nextest
+        uses: taiki-e/install-action@cargo-nextest
+      - name: Run Clippy
+        run: cargo clippy --locked --workspace --all-targets --all-features -- -D warnings
+      - name: Run formatting
+        run: cargo fmt --all --check
+      - name: Run Tests
         run: |
-          cargo test --locked --workspace --all-features --all-targets
+          cargo nextest run --all-features --all-targets
-          # Workaround for https://github.com/rust-lang/cargo/issues/6669
           cargo test --locked --workspace --all-features --doc
-  # Run clippy lints.
+      - name: Check Documentation
-  clippy:
-    name: Clippy
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-      - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          components: clippy
-      - name: Install dependencies
-        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
-      - name: Populate target directory from cache
-        uses: Leafwing-Studios/cargo-cache@v2
-        with:
-          sweep-cache: true
-      - name: Run clippy lints
-        run: cargo clippy --locked --workspace --all-features -- --deny warnings
-  # Check formatting.
-  format:
-    name: Format
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-      - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt
-      - name: Run cargo fmt
-        run: cargo fmt --all -- --check
-  # Check documentation.
-  doc:
-    name: Docs
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-      - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
-      - name: Install dependencies
-        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
-      - name: Populate target directory from cache
-        uses: Leafwing-Studios/cargo-cache@v2
-        with:
-          sweep-cache: true
-      - name: Check documentation
         run: cargo doc --locked --workspace --all-features --document-private-items --no-deps

src/builder.rs

@@ -190,7 +190,7 @@ pub fn create_hex_maze(radius: u16) -> Maze {
 #[cfg(test)]
 mod test {
     use super::*;
-    use claims::assert_gt;
+    use claims::{assert_gt, assert_some};
     use rstest::rstest;
 
     #[test]
@@ -249,8 +249,8 @@ mod test {
             Hex::new(0, -2),
             Hex::new(1, -2),
         ];
-        for pos in expected_positions.iter() {
+        for pos in &expected_positions {
-            assert!(maze.get(pos).is_some(), "Expected tile at {:?}", pos);
+            assert_some!(maze.get(pos), "Expected tile at {pos:?}");
         }
     }
 }

src/generator/backtrack.rs

@@ -44,6 +44,7 @@ fn recursive_backtrack<R: Rng>(
 mod test {
     use super::*;
     use crate::builder::create_hex_maze;
+    use claims::assert_some;
     use rstest::rstest;
 
     #[rstest]
@@ -72,7 +73,7 @@ mod test {
         recursive_backtrack(&mut maze, start, &mut visited, &mut rng);
 
         for &pos in maze.keys() {
-            let walls = maze.get_walls(&pos).unwrap();
+            let walls = assert_some!(maze.get_walls(&pos));
             assert!(
                 walls.count() < 6,
                 "At least one wall should be removed for each tile"

src/generator/mod.rs

@@ -15,6 +15,7 @@ pub enum GeneratorType {
     #[default]
     RecursiveBacktracking,
 }
+
 impl GeneratorType {
     pub fn generate(&self, maze: &mut Maze, start_pos: Option<Hex>, seed: Option<u64>) {
         match self {

src/tile.rs

@@ -236,7 +236,7 @@ mod test {
             let layout = HexLayout::default();
             let tile = Tile::new(Hex::new(1, 0));
             let vec2 = tile.to_vec2(&layout);
-            assert_eq!(vec2, Vec2::new(1.5, -0.8660254));
+            assert_eq!(vec2, Vec2::new(1.5, -0.866_025_4));
         }
 
         #[test]
@@ -244,7 +244,7 @@ mod test {
             let layout = HexLayout::default();
             let tile = Tile::new(Hex::new(0, 1));
             let vec3 = tile.to_vec3(&layout);
-            assert_eq!(vec3, Vec3::new(0.0, 0.0, -1.7320508));
+            assert_eq!(vec3, Vec3::new(0.0, 0.0, -1.732_050_8));
         }
     }
 }

src/walls.rs

@@ -375,7 +375,7 @@ mod test {
         let walls = Walls::all_directions();
         assert!(walls.is_enclosed());
         assert!(!walls.is_empty());
-        assert_eq!(walls.as_bits(), 0b111111);
+        assert_eq!(walls.as_bits(), 0b11_1111);
     }
 
     // as_bits
@@ -389,7 +389,7 @@ mod test {
     fn as_bits_single_wall() {
         let mut walls = Walls::empty();
         walls.insert(EdgeDirection::FLAT_NORTH);
-        assert_eq!(walls.as_bits(), 0b010000);
+        assert_eq!(walls.as_bits(), 0b01_0000);
     }
 
     #[test]
@@ -397,13 +397,13 @@ mod test {
         let mut walls = Walls::empty();
         walls.insert(EdgeDirection::FLAT_NORTH);
         walls.insert(EdgeDirection::FLAT_SOUTH);
-        assert_eq!(walls.as_bits(), 0b010010);
+        assert_eq!(walls.as_bits(), 0b01_0010);
     }
 
     #[test]
     fn as_bits_all_walls() {
         let walls = Walls::new();
-        assert_eq!(walls.as_bits(), 0b111111);
+        assert_eq!(walls.as_bits(), 0b11_1111);
     }
 
     // new
@@ -411,7 +411,7 @@ mod test {
     fn new_created_closed_walls() {
         let walls = Walls::new();
         assert!(walls.is_enclosed());
-        assert_eq!(walls.as_bits(), 0b111111);
+        assert_eq!(walls.as_bits(), 0b11_1111);
     }
 
     // empty
@@ -520,7 +520,7 @@ mod test {
     fn default_creates_closed_walls() {
         let walls = Walls::default();
         assert!(walls.is_enclosed());
-        assert_eq!(walls.as_bits(), 0b111111);
+        assert_eq!(walls.as_bits(), 0b11_1111);
     }
 
     #[test]
@@ -542,53 +542,53 @@ mod test {
 
         // Test single bit operations
         walls.insert(EdgeDirection::FLAT_NORTH);
-        assert_eq!(walls.as_bits(), 0b010000);
+        assert_eq!(walls.as_bits(), 0b01_0000);
 
         walls.insert(EdgeDirection::FLAT_SOUTH);
-        assert_eq!(walls.as_bits(), 0b010010);
+        assert_eq!(walls.as_bits(), 0b01_0010);
 
         // Test removing middle bit
         walls.insert(EdgeDirection::FLAT_SOUTH_EAST);
-        assert_eq!(walls.as_bits(), 0b010011);
+        assert_eq!(walls.as_bits(), 0b01_0011);
         walls.remove(EdgeDirection::FLAT_SOUTH);
-        assert_eq!(walls.as_bits(), 0b010001);
+        assert_eq!(walls.as_bits(), 0b01_0001);
     }
 
     // From<EdgeDirection> tests
     #[test]
     fn from_edge_direction_flat_south_east() {
         let walls = Walls::from(EdgeDirection::FLAT_SOUTH_EAST);
-        assert_eq!(walls.as_bits(), 0b000001);
+        assert_eq!(walls.as_bits(), 0b00_0001);
     }
 
     #[test]
     fn from_edge_direction_flat_south() {
         let walls = Walls::from(EdgeDirection::FLAT_SOUTH);
-        assert_eq!(walls.as_bits(), 0b000010);
+        assert_eq!(walls.as_bits(), 0b00_0010);
     }
 
     #[test]
     fn from_edge_direction_flat_south_west() {
         let walls = Walls::from(EdgeDirection::FLAT_SOUTH_WEST);
-        assert_eq!(walls.as_bits(), 0b000100);
+        assert_eq!(walls.as_bits(), 0b00_0100);
     }
 
     #[test]
     fn from_edge_direction_flat_north_west() {
         let walls = Walls::from(EdgeDirection::FLAT_NORTH_WEST);
-        assert_eq!(walls.as_bits(), 0b001000);
+        assert_eq!(walls.as_bits(), 0b00_1000);
     }
 
     #[test]
     fn from_edge_direction_flat_north() {
         let walls = Walls::from(EdgeDirection::FLAT_NORTH);
-        assert_eq!(walls.as_bits(), 0b010000);
+        assert_eq!(walls.as_bits(), 0b01_0000);
     }
 
     #[test]
     fn from_edge_direction_flat_east() {
         let walls = Walls::from(EdgeDirection::FLAT_NORTH_EAST);
-        assert_eq!(walls.as_bits(), 0b100000);
+        assert_eq!(walls.as_bits(), 0b10_0000);
     }
 
     // FromIterator tests
@@ -603,7 +603,7 @@ mod test {
         let walls = vec![EdgeDirection::FLAT_SOUTH]
             .into_iter()
             .collect::<Walls>();
-        assert_eq!(walls.as_bits(), 0b000010);
+        assert_eq!(walls.as_bits(), 0b00_0010);
     }
 
     #[test]
@@ -611,7 +611,7 @@ mod test {
         let walls = vec![EdgeDirection::FLAT_NORTH, EdgeDirection::FLAT_SOUTH]
             .into_iter()
             .collect::<Walls>();
-        assert_eq!(walls.as_bits(), 0b010010);
+        assert_eq!(walls.as_bits(), 0b01_0010);
     }
 
     #[test]
@@ -623,13 +623,13 @@ mod test {
         ]
         .into_iter()
         .collect::<Walls>();
-        assert_eq!(walls.as_bits(), 0b010010);
+        assert_eq!(walls.as_bits(), 0b01_0010);
     }
 
     #[test]
     fn from_iterator_all_directions() {
         let walls = EdgeDirection::iter().collect::<Walls>();
-        assert_eq!(walls.as_bits(), 0b111111);
+        assert_eq!(walls.as_bits(), 0b11_1111);
     }
 
     // From<[EdgeDirection; N]> tests
@@ -642,13 +642,13 @@ mod test {
     #[test]
     fn from_array_single() {
         let walls = Walls::from([EdgeDirection::FLAT_NORTH]);
-        assert_eq!(walls.as_bits(), 0b010000);
+        assert_eq!(walls.as_bits(), 0b01_0000);
     }
 
     #[test]
     fn from_array_multiple() {
         let walls = Walls::from([EdgeDirection::FLAT_NORTH, EdgeDirection::FLAT_SOUTH]);
-        assert_eq!(walls.as_bits(), 0b010010);
+        assert_eq!(walls.as_bits(), 0b01_0010);
     }
 
     #[test]
@@ -658,7 +658,7 @@ mod test {
             EdgeDirection::FLAT_NORTH,
             EdgeDirection::FLAT_SOUTH,
         ]);
-        assert_eq!(walls.as_bits(), 0b010010);
+        assert_eq!(walls.as_bits(), 0b01_0010);
     }
 
     #[test]
@@ -671,6 +671,6 @@ mod test {
             EdgeDirection::FLAT_SOUTH_WEST,
             EdgeDirection::FLAT_NORTH_WEST,
         ]);
-        assert_eq!(walls.as_bits(), 0b111111);
+        assert_eq!(walls.as_bits(), 0b11_1111);
     }
 }

tests/builder.rs

@@ -67,28 +67,24 @@ fn maze_connectivity() {
     let maze = assert_ok!(MazeBuilder::new().with_radius(3).build());
 
     // Helper function to count accessible neighbors
-    fn count_accessible_neighbors(maze: &Maze, pos: Hex) -> usize {
+    let count_accessible_neighbors = |pos: Hex| -> usize {
         hexx::EdgeDirection::ALL_DIRECTIONS
             .iter()
             .filter(|&&dir| {
                 let neighbor = pos + dir;
-                if let Some(walls) = maze.get_walls(&pos) {
+                maze.get_walls(&pos)
-                    !walls.contains(dir) && maze.get(&neighbor).is_some()
+                    .is_some_and(|walls| !walls.contains(dir) && maze.get(&neighbor).is_some())
-                } else {
-                    false
-                }
             })
             .count()
-    }
+    };
 
     // Check that each tile has at least one connection
     for &pos in maze.keys() {
-        let accessible_neighbors = count_accessible_neighbors(&maze, pos);
+        let accessible_neighbors = count_accessible_neighbors(pos);
-        claims::assert_gt!(
+        assert_gt!(
             accessible_neighbors,
             0,
-            "Tile at {:?} has no accessible neighbors",
+            "Tile at {pos:?} has no accessible neighbors",
-            pos
         );
     }
 }
@@ -96,10 +92,9 @@ fn maze_connectivity() {
 #[test]
 fn maze_boundaries() {
     let radius = 3;
-    let maze = MazeBuilder::new()
+    let maze = assert_ok!(MazeBuilder::new().with_radius(radius).build());
-        .with_radius(radius as u16)
+
-        .build()
+    let radius = i32::from(radius);
-        .unwrap();
 
     // Test that tiles exist within the radius
     for q in -radius..=radius {
@@ -108,8 +103,7 @@ fn maze_boundaries() {
             if q.abs() + r.abs() <= radius {
                 assert!(
                     maze.get(&pos).is_some(),
-                    "Expected tile at {:?} to exist",
+                    "Expected tile at {pos:?} to exist",
-                    pos
                 );
             }
         }

tests/generator.rs

@@ -1,3 +1,4 @@
+use claims::assert_some;
 use hexlab::prelude::*;
 use rstest::rstest;
 
@@ -46,11 +47,10 @@ fn generator_type(
 
     // Check that each tile has at least one open wall
     for &pos in maze.keys() {
-        let walls = maze.get_walls(&pos).unwrap();
+        let walls = assert_some!(maze.get_walls(&pos));
         assert!(
             walls.count() < 6,
-            "Tile at {:?} should have at least one open wall",
+            "Tile at {pos:?} should have at least one open wall",
-            pos
         );
     }
 }

tests/maze.rs

@@ -1,3 +1,4 @@
+use claims::assert_some;
 use hexlab::prelude::*;
 
 #[test]
@@ -10,9 +11,8 @@ fn hex_maze_creation_and_basic_operations() {
     assert_eq!(maze.count(), 1);
     assert!(!maze.is_empty());
 
-    let tile = maze.get(&center);
+    let tile = assert_some!(maze.get(&center));
-    assert!(tile.is_some());
+    assert_eq!(tile.pos(), center);
-    assert_eq!(tile.unwrap().pos(), center);
 }
 
 #[test]
@@ -26,7 +26,7 @@ fn hex_maze_wall_operations() {
         let _ = maze.add_tile_wall(&center, direction);
     }
 
-    let walls = maze.get_walls(&center).unwrap();
+    let walls = assert_some!(maze.get_walls(&center));
     assert_eq!(walls.count(), 6);
 
     // Remove walls
@@ -34,7 +34,7 @@ fn hex_maze_wall_operations() {
         let _ = maze.remove_tile_wall(&center, direction);
     }
 
-    let walls = maze.get_walls(&center).unwrap();
+    let walls = assert_some!(maze.get_walls(&center));
     assert_eq!(walls.count(), 0);
 }