featureparity 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3dba0cc6ba18239f6952822d96bd4526d26d207e8b7e5448554de745e6517a8
-  data.tar.gz: 1521147f4b1574062b3e04f22cef0ce1cb7ef6b822f767c3f75ed66a200b6a5c
+  metadata.gz: 7fc65a33008ccbd43f9b8ec10f7e3c013ab3ed502980f97b64c55e14ff1d2eb5
+  data.tar.gz: a841a639236c27ea6bf7c30ba1a7f4a5710176bc0fd4bb153daac009d89e90db
 SHA512:
-  metadata.gz: a65ac140de45599a9a5a27f4705e179fd816bad77fe563477fd6b92efbc0d592cea80f8c90c2e519d559fc604927d6b321c3a3af99bb10c2b99b9e06b39467f5
-  data.tar.gz: c9ba4966e9a2d036f266b3646eb0c7569399d606d196175df189047de7693c55badce253c94205045449ca7b20117a6f496eeee486067c03ca2291f2caed026f
+  metadata.gz: df0c381690d9fa55e189e3a057eddd35c979bb970fac56b9294ad426d758613374c483c5f4317829cedd5a85d3ff3443a543e8dbcfdff99a146a82c7de831c53
+  data.tar.gz: f2d8dd3a182c74e6e7ef5e4395803eaf86a62b510532227c2b7ec4c3bf4a3fe06db62c8866280d016c7cb4d1cb6a786b2b5c2dcb731f5f0ada518de288eb3714

data/lib/fp/junit.rb

@@ -46,8 +46,10 @@ module Fp
     # A testcase paired with the marker that annotates it. `precise` records whether we
     # know *which* test the marker sits above (matched by line or by test name) or only
     # that the marker is somewhere in the same file — a title is only worth reporting in
-    # the first case.
-    Match = Struct.new(:testcase, :marker, :precise, keyword_init: true)
+    # the first case. `repo_file` is the testcase's source path made relative to the git
+    # repo root (see repo_relative_file), so evidence links resolve regardless of the
+    # base_dir the runner reported paths against.
+    Match = Struct.new(:testcase, :marker, :precise, :repo_file, keyword_init: true)
 
     # Evidence discovered by binding a testcase to a marker.
     # `line` is the 1-based line number of the test in its source file: the
@@ -191,7 +193,7 @@ module Fp
           if surface.nil? || surface.empty?
             missing_surface << { slug: marker[:slug], file: tc.file }
           else
-            record_binding(bindings, marker[:slug], surface, tc, marker, titles_reliable: match.precise)
+            record_binding(bindings, marker[:slug], surface, tc, marker, match.repo_file, titles_reliable: match.precise)
           end
         end
       end
@@ -232,7 +234,7 @@ module Fp
           end
 
           key = [marker[:slug], surface]
-          agg = aggregates[key] ||= { file: tc.file, line: tc.line || marker[:line], ran: 0, failed: 0, skipped: 0 }
+          agg = aggregates[key] ||= { file: match.repo_file || tc.file, line: tc.line || marker[:line], ran: 0, failed: 0, skipped: 0 }
           if tc.stub?
             agg[:skipped] += 1
           else
@@ -274,17 +276,23 @@ module Fp
     # can never disagree about which test a marker annotates.
     def walk_matches(testcases, base_dir)
       marker_cache = {}
+      prefix_cache = {}
 
       # Group testcases by their source file so we can reason about ordering.
-      testcases.group_by(&:file).each do |_file, cases|
+      testcases.group_by(&:file).each do |file, cases|
         markers = markers_for(cases.first, base_dir, marker_cache)
         next if markers.empty?
 
+        # The path we'll store as evidence: relative to the git root, not to base_dir,
+        # so a GitHub blob link resolves. base_dir's offset below the root is cached, so
+        # this is one shell-out per run, not per file.
+        repo_file = repo_relative_file(file, base_dir, prefix_cache)
+
         cases.each do |tc|
           marker, precise = marker_for(tc, cases, markers)
           next unless marker
 
-          yield Match.new(testcase: tc, marker: marker, precise: precise)
+          yield Match.new(testcase: tc, marker: marker, precise: precise, repo_file: repo_file)
         end
       end
     end
@@ -363,8 +371,8 @@ module Fp
       candidate
     end
 
-    def record_binding(bindings, slug, surface, testcase, marker, titles_reliable: true)
-      rel_file = testcase.file
+    def record_binding(bindings, slug, surface, testcase, marker, repo_file, titles_reliable: true)
+      rel_file = repo_file || testcase.file
       key = [slug, surface, rel_file]
       state = testcase.stub? ? 'stub' : 'present'
 
@@ -400,6 +408,70 @@ module Fp
       cache[file] = markers
     end
 
+    # Rewrite a report-relative test-file path so it is relative to the git repo root.
+    #
+    # Runners report paths relative to wherever they ran: RSpec/minitest from the repo
+    # root, but vitest from its own package (frontend/), which is why the web job passes
+    # `--base-dir frontend`. That base_dir is enough to *find* the markers, but the path
+    # we then store as `source_file` was the raw report path (`src/pages/Matrix.test.jsx`),
+    # not the repo-root path (`frontend/src/pages/Matrix.test.jsx`). The web app builds a
+    # GitHub link as `blob/<sha>/<source_file>`, and a blob path is always relative to the
+    # git root — so the missing `frontend/` prefix produced a 404 on every web test link.
+    #
+    # The fix is purely additive: find how far base_dir sits below the git root and
+    # prepend that. When base_dir *is* the git root (the Ruby suites, run from the repo
+    # root), the prefix is empty and the original path is returned byte-for-byte — so this
+    # only ever corrects a subdirectory base_dir and never rewrites a path that was
+    # already right. Falls back to the raw path when there's no git checkout (an agent
+    # running from a tarball) or base_dir sits outside one.
+    def repo_relative_file(file, base_dir, cache = {})
+      return file if file.nil? || file.empty?
+
+      prefix = base_dir_prefix(base_dir, cache)
+      return file if prefix.nil? || prefix.empty?
+
+      File.join(prefix, file)
+    end
+
+    # base_dir's path relative to the git root that contains it: '' when base_dir is the
+    # root, 'frontend' when it's a package below it, nil when base_dir isn't in a checkout
+    # (or sits above the root). Cached per base_dir so a report shells out once.
+    def base_dir_prefix(base_dir, cache)
+      absolute = File.expand_path(base_dir)
+      return cache[absolute] if cache.key?(absolute)
+
+      root = git_toplevel_for(absolute)
+      prefix =
+        if root.nil?
+          nil
+        else
+          rel = relative_path(absolute, root)
+          rel == '.' || rel.start_with?('..') ? '' : rel
+        end
+      cache[absolute] = prefix
+    end
+
+    # The git repo root containing `dir`, or nil if `dir` isn't inside a checkout.
+    def git_toplevel_for(dir)
+      out = `git -C #{quote(dir)} rev-parse --show-toplevel 2>/dev/null`
+      root = out.strip
+      ($?&.success? && !root.empty?) ? File.expand_path(root) : nil
+    end
+
+    def relative_path(absolute, root)
+      require 'pathname'
+      Pathname.new(absolute).relative_path_from(Pathname.new(root)).to_s
+    rescue ArgumentError
+      # Different roots on Windows, or otherwise not relative — treat as outside.
+      '..'
+    end
+
+    # Minimal shell-quote for a path passed to `git -C`. The directory comes from
+    # --base-dir, not arbitrary report content, but quoting keeps spaces safe.
+    def quote(str)
+      "'#{str.gsub("'", "'\\\\''")}'"
+    end
+
     # Scan file contents for fp:<slug>[@surface[,surface...]] markers, returning
     # [{ slug:, surfaces: [..], line:, title:, title_kind: }, ...] (1-based line numbers).
     # `surfaces` is [] when the marker pins none (use the default surface).

data/lib/fp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fp
-  VERSION = '0.0.13'
+  VERSION = '0.0.14'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: featureparity
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Stowzilla