ci: setup codecov coverage & badge

.github/workflows/coverage.yaml

@@ -9,6 +9,8 @@ env:
 jobs:
   coverage:
     runs-on: ubuntu-latest
+    env:
+      COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }}
     steps:
       - name: Checkout code
         uses: actions/checkout@v5
@@ -46,12 +48,41 @@ jobs:
 
       - name: Generate coverage report
         run: |
-          just coverage-codecov
+          just coverage
 
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
-          files: ./codecov.json
+          files: lcov.info
-          disable_search: true
+
-          verbose: true
+      - name: Download Coveralls CLI
+        if: ${{ env.COVERALLS_REPO_TOKEN != '' }}
+        run: |
+          # use GitHub Releases URL instead of coveralls.io because they can't maintain their own files; it 404s
+          curl -L https://github.com/coverallsapp/coverage-reporter/releases/download/v0.6.15/coveralls-linux-x86_64.tar.gz | tar -xz -C /usr/local/bin
+
+      - name: Upload coverage to Coveralls
+        if: ${{ env.COVERALLS_REPO_TOKEN != '' }}
+        run: |
+          if [ ! -f "lcov.info" ]; then
+            echo "Error: lcov.info file not found. Coverage generation may have failed."
+            exit 1
+          fi
+
+          for i in {1..10}; do
+            echo "Attempt $i: Uploading coverage to Coveralls..."
+            if coveralls -n report lcov.info; then
+              echo "Successfully uploaded coverage report."
+              exit 0
+            fi
+
+            if [ $i -lt 10 ]; then
+              delay=$((2**i))
+              echo "Attempt $i failed. Retrying in $delay seconds..."
+              sleep $delay
+            fi
+          done
+
+          echo "Failed to upload coverage report after 10 attempts."
+          exit 1

.gitignore

@@ -14,7 +14,6 @@ assets/site/build.css
 
 # Coverage reports
 lcov.info
-codecov.json
 coverage.html
 
 # Profiling output

Justfile

@@ -2,8 +2,8 @@ set shell := ["bash", "-c"]
 set windows-shell := ["powershell.exe", "-NoLogo", "-Command"]
 
 # Regex to exclude files from coverage report, double escapes for Justfile + CLI
-# You can use src/..., but the filename alone is acceptable too
+# You can use src\\\\..., but the filename alone is acceptable too
-coverage_exclude_pattern := "src/app\\.rs|audio\\.rs|src/error\\.rs|platform/emscripten\\.rs|bin/.+\\.rs|main\\.rs|platform/desktop\\.rs|platform/tracing_buffer\\.rs|platform/buffered_writer\\.rs|systems/debug\\.rs|systems/profiling\\.rs"
+coverage_exclude_pattern := "src\\\\app\\.rs|audio\\.rs|src\\\\error\\.rs|platform\\\\emscripten\\.rs|bin\\\\.+\\.rs|main\\.rs|platform\\\\desktop\\.rs|platform\\\\tracing_buffer\\.rs|platform\\\\buffered_writer\\.rs|systems\\\\debug\\.rs|systems\\\\profiling\\.rs"
 
 binary_extension := if os() == "windows" { ".exe" } else { "" }
 
@@ -11,7 +11,7 @@ binary_extension := if os() == "windows" { ".exe" } else { "" }
 # !!! --remap-path-prefix prevents the absolute path from being used in the generated report
 
 # Generate HTML report (for humans, source line inspection)
-html: coverage-lcov
+html: coverage
     cargo llvm-cov report \
     --remap-path-prefix \
     --ignore-filename-regex "{{ coverage_exclude_pattern }}" \
@@ -19,13 +19,13 @@ html: coverage-lcov
     --open
 
 # Display report (for humans)
-report-coverage: coverage-lcov
+report-coverage: coverage
     cargo llvm-cov report \
     --remap-path-prefix \
     --ignore-filename-regex "{{ coverage_exclude_pattern }}"
 
-# Run & generate LCOV report (as base report)
+# Run & generate report (for CI)
-coverage-lcov:
+coverage:
     cargo llvm-cov \
     --lcov \
     --remap-path-prefix \
@@ -34,16 +34,6 @@ coverage-lcov:
     --profile coverage \
     --no-fail-fast nextest
 
-# Run & generate Codecov report (for CI)
-coverage-codecov:
-    cargo llvm-cov \
-    --codecov \
-    --remap-path-prefix \
-    --ignore-filename-regex "{{ coverage_exclude_pattern }}" \
-    --output-path codecov.json \
-    --profile coverage \
-    --no-fail-fast nextest
-
 # Profile the project using 'samply'
 samply:
     cargo build --profile profile

codecov.yml

@@ -1,3 +0,0 @@
-ignore:
-  - "src/(?:bin|platform))/.+\\.rs"
-  - "src/(?:app|events|formatter)\\.rs"

src/systems/debug.rs

@@ -266,7 +266,7 @@ pub fn debug_render_system(
     }
 
     canvas.set_draw_color(Color {
-        a: f32_to_u8(0.65),
+        a: f32_to_u8(0.6),
         ..Color::RED
     });
     canvas.set_blend_mode(sdl2::render::BlendMode::Blend);

src/texture/sprites.rs

@@ -15,8 +15,6 @@ pub enum PacmanSprite {
     Moving(Direction, u8),
     /// The full, closed-mouth Pac-Man sprite.
     Full,
-    /// A single frame of the dying animation.
-    Dying(u8),
 }
 
 /// Represents the color of a frightened ghost.
@@ -62,50 +60,45 @@ impl GameSprite {
     /// This path corresponds to the filename in the texture atlas JSON file.
     pub fn to_path(self) -> String {
         match self {
-            GameSprite::Pacman(PacmanSprite::Moving(dir, frame)) => format!(
+            GameSprite::Pacman(sprite) => match sprite {
-                "pacman/{}_{}.png",
+                PacmanSprite::Moving(dir, frame) => {
-                dir.as_ref(),
+                    let frame_char = match frame {
-                match frame {
+                        0 => 'a',
-                    0 => "a",
+                        1 => 'b',
-                    1 => "b",
+                        _ => panic!("Invalid animation frame"),
-                    _ => panic!("Invalid animation frame"),
+                    };
+                    format!("pacman/{}_{}.png", dir.as_ref().to_lowercase(), frame_char)
                 }
-            ),
+                PacmanSprite::Full => "pacman/full.png".to_string(),
-            GameSprite::Pacman(PacmanSprite::Full) => "pacman/full.png".to_string(),
+            },
-            GameSprite::Pacman(PacmanSprite::Dying(frame)) => format!("pacman/death/{}.png", frame),
+            GameSprite::Ghost(sprite) => match sprite {
-
+                GhostSprite::Normal(ghost, dir, frame) => {
-            // Ghost sprites
+                    let frame_char = match frame {
-            GameSprite::Ghost(GhostSprite::Normal(ghost_type, dir, frame)) => {
+                        0 => 'a',
-                let frame_char = match frame {
+                        1 => 'b',
-                    0 => 'a',
+                        _ => panic!("Invalid animation frame"),
-                    1 => 'b',
+                    };
-                    _ => panic!("Invalid animation frame"),
+                    format!("ghost/{}/{}_{}.png", ghost.as_str(), dir.as_ref().to_lowercase(), frame_char)
-                };
+                }
-                format!(
+                GhostSprite::Frightened(color, frame) => {
-                    "ghost/{}/{}_{}.png",
+                    let frame_char = match frame {
-                    ghost_type.as_str(),
+                        0 => 'a',
-                    dir.as_ref().to_lowercase(),
+                        1 => 'b',
-                    frame_char
+                        _ => panic!("Invalid animation frame"),
-                )
+                    };
-            }
+                    let color_str = match color {
-            GameSprite::Ghost(GhostSprite::Frightened(color, frame)) => {
+                        FrightenedColor::Blue => "blue",
-                let frame_char = match frame {
+                        FrightenedColor::White => "white",
-                    0 => 'a',
+                    };
-                    1 => 'b',
+                    format!("ghost/frightened/{}_{}.png", color_str, frame_char)
-                    _ => panic!("Invalid animation frame"),
+                }
-                };
+                GhostSprite::Eyes(dir) => format!("ghost/eyes/{}.png", dir.as_ref().to_lowercase()),
-                let color_str = match color {
+            },
-                    FrightenedColor::Blue => "blue",
+            GameSprite::Maze(sprite) => match sprite {
-                    FrightenedColor::White => "white",
+                MazeSprite::Tile(index) => format!("maze/tiles/{}.png", index),
-                };
+                MazeSprite::Pellet => "maze/pellet.png".to_string(),
-                format!("ghost/frightened/{}_{}.png", color_str, frame_char)
+                MazeSprite::Energizer => "maze/energizer.png".to_string(),
-            }
+            },
-            GameSprite::Ghost(GhostSprite::Eyes(dir)) => format!("ghost/eyes/{}.png", dir.as_ref().to_lowercase()),
-
-            // Maze sprites
-            GameSprite::Maze(MazeSprite::Tile(index)) => format!("maze/tiles/{}.png", index),
-            GameSprite::Maze(MazeSprite::Pellet) => "maze/pellet.png".to_string(),
-            GameSprite::Maze(MazeSprite::Energizer) => "maze/energizer.png".to_string(),
         }
     }
 }

tests/sprites.rs

@@ -1,73 +0,0 @@
-//! Tests for the sprite path generation.
-use pacman::{
-    game::ATLAS_FRAMES,
-    map::direction::Direction,
-    systems::components::Ghost,
-    texture::sprites::{FrightenedColor, GameSprite, GhostSprite, MazeSprite, PacmanSprite},
-};
-
-#[test]
-fn test_all_sprite_paths_exist() {
-    let mut sprites_to_test = Vec::new();
-
-    // Pac-Man sprites
-    for &dir in &[Direction::Up, Direction::Down, Direction::Left, Direction::Right] {
-        for frame in 0..2 {
-            sprites_to_test.push(GameSprite::Pacman(PacmanSprite::Moving(dir, frame)));
-        }
-    }
-    sprites_to_test.push(GameSprite::Pacman(PacmanSprite::Full));
-    for frame in 0..=10 {
-        sprites_to_test.push(GameSprite::Pacman(PacmanSprite::Dying(frame)));
-    }
-
-    // Ghost sprites
-    for &ghost in &[Ghost::Blinky, Ghost::Pinky, Ghost::Inky, Ghost::Clyde] {
-        for &dir in &[Direction::Up, Direction::Down, Direction::Left, Direction::Right] {
-            for frame in 0..2 {
-                sprites_to_test.push(GameSprite::Ghost(GhostSprite::Normal(ghost, dir, frame)));
-            }
-            sprites_to_test.push(GameSprite::Ghost(GhostSprite::Eyes(dir)));
-        }
-    }
-    for &color in &[FrightenedColor::Blue, FrightenedColor::White] {
-        for frame in 0..2 {
-            sprites_to_test.push(GameSprite::Ghost(GhostSprite::Frightened(color, frame)));
-        }
-    }
-
-    // Maze sprites
-    for i in 0..=34 {
-        sprites_to_test.push(GameSprite::Maze(MazeSprite::Tile(i)));
-    }
-    sprites_to_test.push(GameSprite::Maze(MazeSprite::Pellet));
-    sprites_to_test.push(GameSprite::Maze(MazeSprite::Energizer));
-
-    for sprite in sprites_to_test {
-        let path = sprite.to_path();
-        assert!(
-            ATLAS_FRAMES.contains_key(&path),
-            "Sprite path '{}' does not exist in the atlas.",
-            path
-        );
-    }
-}
-
-#[test]
-fn test_invalid_sprite_paths_do_not_exist() {
-    let invalid_sprites = vec![
-        // An invalid Pac-Man dying frame
-        GameSprite::Pacman(PacmanSprite::Dying(99)),
-        // An invalid maze tile
-        GameSprite::Maze(MazeSprite::Tile(99)),
-    ];
-
-    for sprite in invalid_sprites {
-        let path = sprite.to_path();
-        assert!(
-            !ATLAS_FRAMES.contains_key(&path),
-            "Invalid sprite path '{}' was found in the atlas, but it should not exist.",
-            path
-        );
-    }
-}