feat: open coverage to a github remote origin in a web browser

Author: zimeg

.envrc

@@ -0,0 +1 @@
+use flake

.gitignore

@@ -0,0 +1,6 @@
+# Development
+.direnv
+.zig-cache
+
+# Build
+zig-out

CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog][changelog], and this project adheres
+to [Semantic Versioning][semver].
+
+## [0.1.0] - 2025-05-03
+
+### Added
+
+- Open coverage to a GitHub remote origin in a web browser with `coverage`.
+
+<!-- a collection of links -->
+
+[changelog]: https://keepachangelog.com/en/1.1.0/
+[semver]: https://semver.org/spec/v2.0.0.html
+
+<!-- a collection of releases -->
+
+[Unreleased]: https://github.com/zimeg/git-coverage/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/zimeg/git-coverage/releases/tag/v0.1.0

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Eden Zimbelman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,17 @@
+# git-coverage
+
+Open test coverage uploaded to [`codecov`][codecov] in a web browser.
+
+## Usage
+
+The following command uses `git` details:
+
+```sh
+$ git coverage  # https://app.codecov.io/gh/zimeg/git-coverage
+```
+
+## Installation
+
+Add a build to `$PATH` for automatic detection.
+
+[codecov]: https://about.codecov.io

build.zig

@@ -0,0 +1,31 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+    const exe_mod = b.createModule(.{
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    const exe = b.addExecutable(.{
+        .name = "git-coverage",
+        .root_module = exe_mod,
+    });
+    b.installArtifact(exe);
+
+    const run_step = b.step("run", "Run the command");
+    const run_cmd = b.addRunArtifact(exe);
+    run_cmd.step.dependOn(b.getInstallStep());
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+    run_step.dependOn(&run_cmd.step);
+
+    const test_step = b.step("test", "Run unit tests");
+    const exe_unit_tests = b.addTest(.{
+        .root_module = exe_mod,
+    });
+    const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
+    test_step.dependOn(&run_exe_unit_tests.step);
+}

flake.lock

@@ -0,0 +1,36 @@
+{
+  description = "open test coverage in a web browser";
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+  outputs =
+    {
+      nixpkgs,
+      flake-utils,
+      ...
+    }:
+    flake-utils.lib.eachDefaultSystem (
+      system:
+      let
+        pkgs = import nixpkgs { inherit system; };
+      in
+      {
+        packages.default = pkgs.stdenv.mkDerivation {
+          pname = "git-coverage";
+          version = "unversioned";
+          src = ./.;
+          nativeBuildInputs = [
+            pkgs.zig.hook
+          ];
+          zigBuildFlags = [ "-Doptimize=ReleaseSmall" ];
+        };
+        devShells.default = pkgs.mkShell {
+          packages = [
+            pkgs.git # https://github.com/git/git
+            pkgs.zig # https://github.com/ziglang/zig
+          ];
+        };
+      }
+    );
+}

flake.nix

@@ -0,0 +1,87 @@
+const std = @import("std");
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var aa = std.heap.ArenaAllocator.init(gpa.allocator());
+    defer aa.deinit();
+    const allocator = aa.allocator();
+    const proc = try std.process.Child.run(.{
+        .allocator = allocator,
+        .argv = &.{ "git", "remote", "-v" },
+    });
+    if (proc.stdout.len <= 0) {
+        return error.GitRemoteMissing;
+    }
+    const remote = try origin(proc.stdout);
+    const project = try repo(remote);
+    const url = try coverage(allocator, project);
+    _ = std.process.Child.run(.{
+        .allocator = allocator,
+        .argv = &[_][]const u8{ "open", url },
+    }) catch {
+        try std.io.getStdOut().writer().print("{s}\n", .{ url });
+    };
+}
+
+fn origin(remotes: []const u8) ![]const u8 {
+    var remote = std.mem.splitScalar(u8, remotes, '\n');
+    while (true) {
+        const line = remote.next();
+        if (line) |val| {
+            if (std.mem.startsWith(u8, val, "origin") and std.mem.endsWith(u8, val, "(push)")) {
+                return std.mem.trim(u8, val[7..val.len-6], " ");
+            }
+        } else {
+            return error.GitOriginMissing;
+        }
+    }
+}
+
+test "origin http" {
+    const remotes = "origin  https://github.com/zimeg/git-coverage.git (fetch)\norigin  https://github.com/zimeg/git-coverage.git (push)";
+    const remote = try origin(remotes);
+    try std.testing.expectEqualStrings(remote, "https://github.com/zimeg/git-coverage.git");
+}
+
+test "origin ssh" {
+    const remotes = "origin  git@github.com:zimeg/git-coverage.git (fetch)\norigin  git@github.com:zimeg/git-coverage.git (push)";
+    const remote = try origin(remotes);
+    try std.testing.expectEqualStrings(remote, "git@github.com:zimeg/git-coverage.git");
+}
+
+fn repo(remote: []const u8) ![]const u8 {
+    if (std.mem.startsWith(u8, remote, "https://github.com/")) {
+        return remote[19..remote.len-4];
+    }
+    if (std.mem.startsWith(u8, remote, "git@github.com:")) {
+        return remote[15..remote.len-4];
+    }
+    return error.GitProtocolMissing;
+}
+
+test "repo http" {
+    const remote = "https://github.com/zimeg/git-coverage.git";
+    const project = try repo(remote);
+    try std.testing.expectEqualStrings(project, "zimeg/git-coverage");
+}
+
+test "repo ssh" {
+    const remote = "git@github.com:zimeg/git-coverage.git";
+    const project = try repo(remote);
+    try std.testing.expectEqualStrings(project, "zimeg/git-coverage");
+}
+
+fn coverage(allocator: std.mem.Allocator, project: []const u8) ![]const u8 {
+    return std.fmt.allocPrint(
+        allocator,
+        "https://app.codecov.io/gh/{s}",
+        .{ project },
+    );
+}
+
+test "coverage project" {
+    const project = "zimeg/git-coverage";
+    const url = try coverage(std.testing.allocator, project);
+    defer std.testing.allocator.free(url);
+    try std.testing.expectEqualStrings(url, "https://app.codecov.io/gh/zimeg/git-coverage");
+}