cov-loupe 3.0.0 → 4.0.0.pre

data/lib/cov_loupe/resolvers/coverage_line_resolver.rb

@@ -1,19 +1,38 @@
 # frozen_string_literal: true
 
+require_relative '../paths/path_utils'
+
 module CovLoupe
   module Resolvers
+    # Finds a SimpleCov line coverage array for a given file path.
+    #
+    # This is a string-based resolver: it does not touch the filesystem. It
+    # looks up keys in the coverage map using two strategies:
+    # 1) exact match on the provided path
+    # 2) match after stripping the configured root prefix
     class CoverageLineResolver
-      def initialize(cov_data)
+      # @param cov_data [Hash] coverage data map keyed by file path
+      # @param root [String, nil] project root used for path stripping
+      # @param volume_case_sensitive [Boolean] whether the volume is case-sensitive
+      def initialize(cov_data, root:, volume_case_sensitive:)
         @cov_data = cov_data
+        @root = root
+        @normalize_case = !volume_case_sensitive
       end
 
+      # Resolve coverage lines for a file path, trying fallbacks before raising.
+      # @param file_abs [String] absolute file path to resolve
+      # @return [Array<Integer, nil>] SimpleCov-style line coverage array
       def lookup_lines(file_abs)
+        # Normalize the input path first to handle platform-specific differences
+        normalized_path = normalize_path(file_abs)
+
         # First try exact match
-        direct_match = find_direct_match(file_abs)
+        direct_match = find_direct_match(normalized_path)
         return direct_match if direct_match
 
         # Then try without current working directory prefix
-        stripped_match = find_stripped_match(file_abs)
+        stripped_match = find_stripped_match(normalized_path)
         return stripped_match if stripped_match
 
         raise_not_found_error(file_abs)
@@ -22,100 +41,95 @@ module CovLoupe
       attr_reader :cov_data
 
       private def find_direct_match(file_abs)
-        entry = cov_data[file_abs]
-        lines_from_entry(entry)
+        fetch_lines_for_path(file_abs)
       end
 
+      # Try matching a path after removing the root prefix.
       private def find_stripped_match(file_abs)
-        return unless file_abs.start_with?(cwd_with_slash)
+        return unless @root
+
+        normalized_file = normalize_path(file_abs)
+        return unless normalized_file.start_with?(normalized_root_with_slash)
+
+        relative_path = normalized_file[(normalized_root.length + 1)..]
+        fetch_lines_for_path(relative_path)
+      end
+
+      # Fetch lines for a path, resolving normalized separators when needed.
+      private def fetch_lines_for_path(path)
+        key = resolve_key(path)
+        return unless key
+
+        entry = cov_data[key]
+        lines = lines_from_entry(entry)
+        return lines if lines
+
+        raise CorruptCoverageDataError, "Entry for #{path} has no valid lines"
+      end
+
+      private def resolution_root
+        @resolution_root ||= @root
+      end
+
+      private def normalized_root
+        @normalized_root ||= normalize_path(resolution_root)
+      end
 
-        relative_path = file_abs[(cwd.length + 1)..]
-        entry = cov_data[relative_path]
-        lines_from_entry(entry)
+      private def normalized_root_with_slash
+        return unless normalized_root
+
+        @normalized_root_with_slash ||= "#{normalized_root}/"
       end
 
-      private def cwd
-        @cwd ||= Dir.pwd
+      # Resolve the coverage key that matches a path (including normalized variants).
+      private def resolve_key(path)
+        normalized = normalize_path(path)
+        match_keys = cov_data.keys.select { |key| normalize_path(key) == normalized }
+
+        return if match_keys.empty?
+
+        # If exact path match exists and it's the only one, return it
+        return path if cov_data.key?(path) && match_keys.length == 1
+
+        # If multiple matches, raise ambiguity error
+        if match_keys.length > 1
+          raise FileError, "Multiple coverage entries match path #{path}: #{match_keys.join(', ')}"
+        end
+
+        # Single match found, return it
+        match_keys.first
       end
 
-      private def cwd_with_slash
-        @cwd_with_slash ||= "#{cwd}/"
+      # Normalize a path using centralized PathUtils
+      private def normalize_path(path)
+        PathUtils.normalize(path, normalize_case: @normalize_case)
       end
 
       private def raise_not_found_error(file_abs)
-        raise FileError, "No coverage entry found for #{file_abs}"
+        raise FileError, "No coverage entry found for #{normalize_path(file_abs)}"
       end
 
-      # Entry may store exact line coverage, branch-only coverage, or neither.
-      # Prefer the provided `lines` array but fall back to synthesizing one so
-      # callers always receive something enumerable.
+      # Entry may store exact line coverage.
+      #
+      # Validates that the entry contains a properly-formed lines array
+      # with only Integer or nil elements.
       #
-      # Returning nil tells callers to keep searching; the resolver will raise
-      # a FileError if no variant yields coverage data.
+      # @raise [CoverageDataError] if lines array contains invalid elements
+      # @return [Array<Integer, nil>, nil] validated lines array or nil if entry lacks lines
       private def lines_from_entry(entry)
         return unless entry.is_a?(Hash)
 
         lines = entry['lines']
-        return lines if lines.is_a?(Array)
+        return nil unless lines.is_a?(Array)
 
-        synthesize_lines_from_branches(entry['branches'])
-      end
-
-      # Some SimpleCov configurations track only branch coverage. When the
-      # resultset omits the legacy `lines` array we rebuild a minimal substitute
-      # so the rest of the pipeline (summaries, uncovered lines, staleness) can
-      # continue to operate.
-      #
-      # Branch data looks like:
-      #   "[:if, 0, 12, 4, 20, 29]" => { "[:then, ...]" => hits, ... }
-      # We care about the third tuple element (line number). We sum branch-leg
-      # hits per line so the synthetic array still behaves like legacy line
-      # coverage (any positive value counts as executed).
-      private def synthesize_lines_from_branches(branch_data)
-        # Detailed shape and rationale documented in docs/BRANCH_ONLY_COVERAGE.md
-        return unless branch_data.is_a?(Hash) && branch_data.any?
-
-        line_hits = {}
-
-        branch_data
-          .values
-          .select { |targets| targets.is_a?(Hash) } # ignore malformed branch entries
-          .flat_map(&:to_a) # flatten each branch target into [meta, hits]
-          .filter_map do |meta, hits|
-            # Extract the covered line; filter_map discards nil results.
-            line_number = extract_line_number(meta)
-            line_number && [line_number, hits.to_i]
-          end
-          .each do |line_number, hits|
-            line_hits[line_number] = line_hits.fetch(line_number, 0) + hits
-          end
-
-        return if line_hits.empty?
-
-        max_line = line_hits.keys.max
-        # Build a dense array up to the highest line recorded so downstream
-        # consumers see the familiar SimpleCov shape (nil for untouched lines).
-        Array.new(max_line) { |idx| line_hits[idx + 1] }
-      end
-
-      # Branch metadata arrives as either the raw SimpleCov array
-      # (e.g. [:if, 0, 12, 4, 20, 29]) or the stringified JSON version
-      # ("[:if, 0, 12, 4, 20, 29]"). We normalize both forms and pull the line.
-      private def extract_line_number(meta)
-        if meta.is_a?(Array)
-          line_token = meta[2]
-          # Integer(..., exception: false) returns nil on failure, so malformed
-          # tuples quietly drop out of the synthesized array.
-          return Integer(line_token, exception: false)
+        # Validate all elements are Integer or nil
+        invalid_elements = lines.reject { |v| v.nil? || v.is_a?(Integer) }
+        unless invalid_elements.empty?
+          raise CoverageDataError,
+            "Invalid coverage line array: contains non-integer elements: #{invalid_elements.inspect}"
         end
 
-        tokens = meta.to_s.tr('[]', '').split(',').map(&:strip)
-        return if tokens.length < 3
-
-        Integer(tokens[2], exception: false)
-        # Any parsing errors result in nil; callers treat that as "no line".
-      rescue ArgumentError, TypeError
-        nil
+        lines
       end
     end
   end

data/lib/cov_loupe/resolvers/{resolver_factory.rb → resolver_helpers.rb}

@@ -5,23 +5,24 @@ require_relative 'coverage_line_resolver'
 
 module CovLoupe
   module Resolvers
-    class ResolverFactory
+    class ResolverHelpers
       def self.create_resultset_resolver(root: Dir.pwd, resultset: nil, candidates: nil)
         candidates ?
           ResultsetPathResolver.new(root: root, candidates: candidates) :
           ResultsetPathResolver.new(root: root)
       end
 
-      def self.create_coverage_resolver(cov_data)
-        CoverageLineResolver.new(cov_data)
+      def self.create_coverage_resolver(cov_data, root:, volume_case_sensitive:)
+        CoverageLineResolver.new(cov_data, root: root, volume_case_sensitive: volume_case_sensitive)
       end
 
       def self.find_resultset(root, resultset: nil)
         ResultsetPathResolver.new(root: root).find_resultset(resultset: resultset)
       end
 
-      def self.lookup_lines(cov, file_abs)
-        CoverageLineResolver.new(cov).lookup_lines(file_abs)
+      def self.lookup_lines(cov, file_abs, root:, volume_case_sensitive:)
+        CoverageLineResolver.new(cov, root: root,
+          volume_case_sensitive: volume_case_sensitive).lookup_lines(file_abs)
       end
     end
   end

data/lib/cov_loupe/resolvers/resultset_path_resolver.rb

@@ -2,6 +2,9 @@
 
 require 'pathname'
 
+require_relative '../errors/errors'
+require_relative '../paths/path_utils'
+
 module CovLoupe
   module Resolvers
     class ResultsetPathResolver
@@ -39,37 +42,62 @@ module CovLoupe
         candidate = File.join(path, '.resultset.json')
         return candidate if File.file?(candidate)
 
-        raise "No .resultset.json found in directory: #{path}"
+        raise ResultsetNotFoundError, "No .resultset.json found in directory: #{path}"
       end
 
       private def raise_not_found_error_for_file(path)
-        raise "Specified resultset not found: #{path}"
+        raise ResultsetNotFoundError, "Specified resultset not found: #{path}"
       end
 
       private def resolve_fallback
         @candidates
-          .map { |p| File.absolute_path(p, @root) }
+          .map { |p| PathUtils.expand(p, @root) }
           .find { |p| File.file?(p) }
       end
 
       private def normalize_resultset_path(resultset)
-        candidate = Pathname.new(resultset)
-        return candidate.cleanpath.to_s if candidate.absolute?
+        Pathname.new(resultset)
+        expanded_resultset = PathUtils.expand(resultset, Dir.pwd)
+        expanded_root = PathUtils.expand(resultset, @root)
+
+        if ambiguous_resultset_path?(expanded_resultset, expanded_root)
+          raise_ambiguous_resultset_error(expanded_resultset, expanded_root)
+        end
 
-        expanded = File.expand_path(resultset, Dir.pwd)
-        return expanded if within_root?(expanded)
+        return expanded_resultset if valid_resultset_location?(expanded_resultset)
+        return expanded_root if valid_resultset_location?(expanded_root)
 
-        File.absolute_path(resultset, @root)
+        return expanded_resultset if within_root?(expanded_resultset)
+
+        expanded_root
       end
 
       private def within_root?(path)
-        normalized_root = Pathname.new(@root).cleanpath.to_s
-        root_with_sep = normalized_root.end_with?(File::SEPARATOR) ? normalized_root : "#{normalized_root}#{File::SEPARATOR}"
-        path == normalized_root || path.start_with?(root_with_sep)
+        PathUtils.within_root?(path, @root)
+      end
+
+      private def ambiguous_resultset_path?(expanded_pwd, expanded_root)
+        return false if expanded_pwd == expanded_root
+
+        valid_resultset_location?(expanded_pwd) && valid_resultset_location?(expanded_root)
+      end
+
+      private def valid_resultset_location?(path)
+        return true if File.file?(path)
+        return false unless File.directory?(path)
+
+        File.file?(File.join(path, '.resultset.json'))
+      end
+
+      private def raise_ambiguous_resultset_error(expanded_pwd, expanded_root)
+        raise ConfigurationError, "Ambiguous resultset location specified. Both #{expanded_pwd} and #{expanded_root} exist. " \
+                                  'Use `./` or an absolute filespec to disambiguate.'
       end
 
       private def raise_not_found_error
-        raise "Could not find .resultset.json under #{@root.inspect}; run tests or set --resultset option"
+        message = "Could not find .resultset.json under #{@root.inspect}; run tests or set --resultset option"
+        CovLoupe.logger.error(message) if CovLoupe.logger
+        raise ResultsetNotFoundError, message
       end
     end
   end

data/lib/cov_loupe/scripts/command_execution.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'shellwords'
+
+module CovLoupe
+  module Scripts
+    module CommandExecution
+      # Execute a command and return its stdout.
+      #
+      # @param cmd [String, Array<String>] The shell command to run.
+      # @param print_output [Boolean] If true, prints output to stdout/stderr in real-time.
+      # @param fail_on_error [Boolean] If true, aborts execution if the command fails.
+      # @return [String] The stdout output of the command (stripped).
+      def run_command(cmd, print_output: false, fail_on_error: true)
+        if print_output
+          run_streamed(cmd, fail_on_error: fail_on_error)
+        else
+          run_captured(cmd, fail_on_error: fail_on_error)
+        end
+      end
+
+      # Execute a command and return stdout and success status.
+      #
+      # @param cmd [String, Array<String>] The shell command to run.
+      # @return [Array<String, Boolean>] The stdout and success boolean.
+      def run_command_with_status(cmd)
+        stdout, _stderr, status = capture_command(cmd)
+        [stdout.strip, status.success?]
+      rescue Errno::ENOENT
+        ["Command not found: #{command_display(cmd)}", false]
+      end
+
+      # Print an error message and exit with status 1.
+      def abort_with(message)
+        warn "ERROR: #{message}"
+        exit 1
+      end
+
+      # Check if a command exists in the system PATH.
+      def command_exists?(cmd)
+        return true if File.exist?(cmd) && File.executable?(cmd)
+
+        checker = Gem.win_platform? ? 'where' : 'which'
+        system(checker, cmd, out: File::NULL, err: File::NULL)
+      end
+
+      private def run_streamed(cmd, fail_on_error:)
+        puts "→ #{command_display(cmd)}"
+        output = +''
+        status = nil
+
+        begin
+          popen_command(cmd) do |_stdin, stdout_err, wait_thr|
+            stdout_err.each do |line|
+              print line
+              output << line
+            end
+            status = wait_thr.value
+          end
+        rescue Errno::ENOENT
+          abort_with("Command not found: #{command_display(cmd)}") if fail_on_error
+          return ''
+        end
+
+        if fail_on_error && !status&.success?
+          abort_with("Command failed: #{cmd}")
+        end
+
+        output.strip
+      end
+
+      private def run_captured(cmd, fail_on_error:)
+        begin
+          stdout, stderr, status = capture_command(cmd)
+        rescue Errno::ENOENT
+          abort_with("Command not found: #{command_display(cmd)}") if fail_on_error
+          return ''
+        end
+
+        if fail_on_error && !status.success?
+          warn "Error running: #{command_display(cmd)}"
+          warn stderr unless stderr.strip.empty?
+          exit 1
+        end
+
+        stdout.strip
+      end
+
+      private def popen_command(cmd, &)
+        if cmd.is_a?(Array)
+          Open3.popen2e(*cmd, &)
+        else
+          Open3.popen2e(cmd, &)
+        end
+      end
+
+      private def capture_command(cmd)
+        if cmd.is_a?(Array)
+          Open3.capture3(*cmd)
+        else
+          Open3.capture3(cmd)
+        end
+      end
+
+      private def command_display(cmd)
+        return Shellwords.join(cmd) if cmd.is_a?(Array)
+
+        cmd.to_s
+      end
+    end
+  end
+end

data/lib/cov_loupe/scripts/latest_ci_status.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'command_execution'
+
+module CovLoupe
+  module Scripts
+    class LatestCiStatus
+      include CommandExecution
+
+      def call
+        branch = fetch_current_branch
+        puts "Fetching latest CI run for branch: #{branch}..."
+
+        run_data = fetch_latest_run(branch)
+
+        if run_data.nil?
+          puts "No workflow runs found for branch '#{branch}'."
+          return
+        end
+
+        display_run_details(run_data)
+      end
+
+      private def fetch_current_branch
+        run_command(%w[git rev-parse --abbrev-ref HEAD])
+      end
+
+      private def fetch_latest_run(branch)
+        json_output, success = run_command_with_status(
+          ['gh', 'run', 'list', '--branch', branch, '--limit', '1', '--json',
+           'databaseId,status,conclusion,url,displayTitle,createdAt']
+        )
+
+        unless success
+          warn "Failed to fetch runs. Ensure 'gh' is installed and you are authenticated."
+          exit 1
+        end
+
+        runs = JSON.parse(json_output)
+        runs.first
+      end
+
+      private def display_run_details(run)
+        id = run['databaseId']
+        status = run['status']
+        conclusion = run['conclusion']
+        url = run['url']
+        title = run['displayTitle']
+        created_at = run['createdAt']
+
+        color = status_color(status, conclusion)
+        display_status = status == 'completed' ? (conclusion || 'unknown').upcase : status.upcase
+
+        puts "\nLatest Run Details:"
+        puts '-------------------'
+        puts "Title:      #{title}"
+        puts "ID:         #{id}"
+        puts "Time:       #{created_at}"
+        puts "Status:     #{colorize(display_status, color)}"
+        puts "URL:        #{url}"
+
+        handle_status_action(status, conclusion, id)
+      end
+
+      private def handle_status_action(status, conclusion, id)
+        if status == 'completed' && ['failure', 'startup_failure', 'timed_out'].include?(conclusion)
+          puts "\n#{colorize('Fetching failure logs...', 31)}"
+          puts '------------------------'
+          system('gh', 'run', 'view', id.to_s, '--log-failed')
+        elsif status == 'in_progress'
+          puts "\n#{colorize('Build is currently running... ⏳', 34)}"
+          puts "You can watch it with: gh run watch #{id}"
+        elsif status == 'queued'
+          puts "\n#{colorize('Build is queued... 🕒', 34)}"
+        end
+      end
+
+      private def colorize(text, color_code)
+        "\e[#{color_code}m#{text}\e[0m"
+      end
+
+      private def status_color(status, conclusion)
+        if status == 'completed'
+          case conclusion
+          when 'success' then 32 # Green
+          when 'failure', 'startup_failure', 'timed_out' then 31 # Red
+          when 'cancelled' then 33 # Yellow
+          else 37 # White
+          end
+        else
+          34 # Blue for in_progress/queued
+        end
+      end
+    end
+  end
+end