fix(coverage): normalize report and diff paths before intersecting

simplecov reports absolute source paths while git diff emits repo-relative ones, so cj/--coverage-intersect joined them by exact key and matched nothing — every changed file read ":tracked nil" under the working-tree, staged, and branch scopes (whole-project worked only because both sides came from the same simplecov source). A new cj/--coverage-relativize-keys normalizes both tables to repo-relative in cj/--coverage-read-and-display before the intersect; the intersect stays pure. Covered by 5 unit tests plus an integration test that drives the real parsers with an absolute-key report and a relative-key diff.

2 files changed, 152 insertions, 4 deletions

diff --git a/modules/coverage-core.el b/modules/coverage-core.el
index 687a042fe..9b102bb7b 100644
--- a/modules/coverage-core.el
+++ b/modules/coverage-core.el
@@ -249,6 +249,27 @@ Signals `user-error' for any other SCOPE."
 	(maphash (lambda (k _v) (push k keys)) table)
 	(sort keys #'<)))
 
+(defun cj/--coverage-relativize-keys (table root)
+  "Return a copy of TABLE with each file-path key made relative to ROOT.
+An absolute key is relativized against ROOT via `file-relative-name'; an
+already-relative key is kept as-is.  Line-set values are shared, not copied.
+
+`cj/--coverage-parse-simplecov' emits absolute path keys (simplecov reports
+absolute source paths) while `cj/--coverage-parse-diff-output' emits
+repo-relative keys (git's \"+++ b/<path>\").  Both must be normalized to
+repo-relative before `cj/--coverage-intersect' joins them by key, or every
+diff-aware match misses and each changed file reads `:tracked nil'."
+  (let ((result (make-hash-table :test 'equal)))
+	(when table
+	  (maphash
+	   (lambda (path lines)
+		 (let ((key (if (file-name-absolute-p path)
+						(file-relative-name path root)
+					  path)))
+		   (puthash key lines result)))
+	   table))
+	result))
+
 (defun cj/--coverage-intersect (covered changed)
   "Combine COVERED (LCOV) with CHANGED (git diff) into per-file records.
 COVERED and CHANGED are each hash tables from file path to a hash table
@@ -479,10 +500,14 @@ line in the simplecov data — the intersect then classifies each line
 as covered or uncovered.  For diff-aware scopes, the changed set
 comes from `git diff' via `cj/--coverage-changed-lines'."
   (let* ((report-path (funcall (plist-get backend :report-path)))
-		 (covered (cj/--coverage-parse-simplecov report-path))
-		 (changed (if (eq scope 'whole-project)
-					  (cj/--coverage-simplecov-executable-lines report-path)
-					(cj/--coverage-changed-lines scope)))
+		 (root (cj/--coverage-project-root))
+		 (covered (cj/--coverage-relativize-keys
+				   (cj/--coverage-parse-simplecov report-path) root))
+		 (changed (cj/--coverage-relativize-keys
+				   (if (eq scope 'whole-project)
+					   (cj/--coverage-simplecov-executable-lines report-path)
+					 (cj/--coverage-changed-lines scope))
+				   root))
 		 (records (cj/--coverage-intersect covered changed)))
 	(cj/--coverage-render-to-buffer records scope)))
 
diff --git a/tests/test-coverage-core--relativize-keys.el b/tests/test-coverage-core--relativize-keys.el
new file mode 100644
index 000000000..82031cd15
--- /dev/null
+++ b/tests/test-coverage-core--relativize-keys.el
@@ -0,0 +1,123 @@
+;;; test-coverage-core--relativize-keys.el --- Tests for path-key normalization -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; Unit + integration tests for `cj/--coverage-relativize-keys', the helper
+;; that normalizes a file-path-keyed coverage table to repo-relative paths.
+;;
+;; The bug it fixes: `cj/--coverage-parse-simplecov' returns ABSOLUTE path
+;; keys (simplecov/undercover emit absolute source paths), while
+;; `cj/--coverage-parse-diff-output' returns repo-RELATIVE keys (git's
+;; "+++ b/<path>").  `cj/--coverage-intersect' joins the two by exact string
+;; key, so for the diff-aware scopes every changed file was classified
+;; ":tracked nil" — zero matches ever.  Normalizing both tables to
+;; repo-relative before the intersect makes the join work.
+;;
+;; The integration test drives the real parsers (a simplecov JSON fixture
+;; with an absolute key + a git-diff string with the relative key) through
+;; relativize + intersect, and asserts the file is tracked with the right
+;; covered/uncovered split — the end-to-end reproduction of the bug.
+
+;;; Code:
+
+(require 'ert)
+
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+(require 'coverage-core)
+
+(defun test-coverage-relativize--hash-of-lines (pairs)
+  "Build a file → line-set hash table from PAIRS.
+Each pair is (FILE . (LINES...)); LINES becomes a hash-table of line → t."
+  (let ((result (make-hash-table :test 'equal)))
+    (dolist (pair pairs)
+      (let ((lines (make-hash-table :test 'eql)))
+        (dolist (line (cdr pair))
+          (puthash line t lines))
+        (puthash (car pair) lines result)))
+    result))
+
+;;; Normal cases
+
+(ert-deftest test-coverage-relativize-absolute-key-made-relative ()
+  "Normal: an absolute key is relativized against ROOT."
+  (let* ((table (test-coverage-relativize--hash-of-lines
+                 '(("/home/u/.emacs.d/modules/foo.el" 10 11))))
+         (out (cj/--coverage-relativize-keys table "/home/u/.emacs.d")))
+    (should (gethash "modules/foo.el" out))
+    (should (null (gethash "/home/u/.emacs.d/modules/foo.el" out)))))
+
+(ert-deftest test-coverage-relativize-preserves-line-set ()
+  "Normal: the line-set value travels unchanged to the new key."
+  (let* ((table (test-coverage-relativize--hash-of-lines
+                 '(("/r/modules/foo.el" 4 8 15))))
+         (out (cj/--coverage-relativize-keys table "/r"))
+         (lines (gethash "modules/foo.el" out)))
+    (should (hash-table-p lines))
+    (should (gethash 4 lines))
+    (should (gethash 8 lines))
+    (should (gethash 15 lines))))
+
+;;; Boundary cases
+
+(ert-deftest test-coverage-relativize-already-relative-unchanged ()
+  "Boundary: an already-relative key is left as-is, not re-relativized."
+  (let* ((table (test-coverage-relativize--hash-of-lines
+                 '(("modules/foo.el" 1 2))))
+         (out (cj/--coverage-relativize-keys table "/home/u/.emacs.d")))
+    (should (gethash "modules/foo.el" out))
+    (should (= 1 (hash-table-count out)))))
+
+(ert-deftest test-coverage-relativize-empty-table ()
+  "Boundary: an empty table yields an empty table."
+  (let ((out (cj/--coverage-relativize-keys (make-hash-table :test 'equal) "/r")))
+    (should (hash-table-p out))
+    (should (= 0 (hash-table-count out)))))
+
+;;; Error cases
+
+(ert-deftest test-coverage-relativize-nil-table-returns-empty ()
+  "Error: a nil table returns an empty table rather than erroring."
+  (let ((out (cj/--coverage-relativize-keys nil "/r")))
+    (should (hash-table-p out))
+    (should (= 0 (hash-table-count out)))))
+
+;;; Integration — the real bug reproduction
+
+(ert-deftest test-coverage-integration-absolute-report-relative-diff-tracks ()
+  "Integration: a simplecov report (absolute keys) and a git diff (relative
+keys) for the same file intersect as TRACKED once both are relativized.
+This is the diff-aware-scope bug: without normalization the file reads
+\":tracked nil\"."
+  (let* ((root "/tmp/cov-root")
+         (abs-path (concat root "/modules/foo.el"))
+         (report (make-temp-file "cov-report-" nil ".json"))
+         (diff (concat
+                "diff --git a/modules/foo.el b/modules/foo.el\n"
+                "index 1111111..2222222 100644\n"
+                "--- a/modules/foo.el\n"
+                "+++ b/modules/foo.el\n"
+                "@@ -2,0 +2,3 @@\n"
+                "+line two\n"
+                "+line three\n"
+                "+line four\n")))
+    (unwind-protect
+        (progn
+          ;; simplecov array: index1=null, 2=hit, 3=0-hits, 4=hit
+          ;; → covered lines {2, 4}
+          (with-temp-file report
+            (insert (format "{\"t\":{\"coverage\":{%S:[null,1,0,2]}}}" abs-path)))
+          (let* ((covered (cj/--coverage-relativize-keys
+                           (cj/--coverage-parse-simplecov report) root))
+                 (changed (cj/--coverage-relativize-keys
+                           (cj/--coverage-parse-diff-output diff) root))
+                 (records (cj/--coverage-intersect covered changed))
+                 (record (car records)))
+            (should (= 1 (length records)))
+            (should (equal "modules/foo.el" (plist-get record :path)))
+            (should (eq t (plist-get record :tracked)))
+            (should (equal '(2 3 4) (plist-get record :changed-lines)))
+            (should (equal '(2 4) (plist-get record :covered-lines)))
+            (should (equal '(3) (plist-get record :uncovered-lines)))))
+      (delete-file report))))
+
+(provide 'test-coverage-core--relativize-keys)
+;;; test-coverage-core--relativize-keys.el ends here