coverage-reporter 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '084368a5d340a21403c9f358fbbd599cd48dc48dd429aec44a40b6eddfec5b4f'
-  data.tar.gz: 4f9f847624fe3f1a5692f757d316254f41eee376643bfb8f790edac4f89a228d
+  metadata.gz: 26f9788a49eb6c65e9b2557867211edfc74ed886c68fd785938d2590421e1136
+  data.tar.gz: b76e32c4a1a6d64881e31449f25325ce977d54130a02ddce7ae6a1fb5cafabcb
 SHA512:
-  metadata.gz: e6aca8f9a84ff71d7570967e115ae2e17652e9c0514f18396f21a069222e30f7343ea7b9f11522a932f62edf1373ef081491a232ed6b8ebabe0c87fd868022cb
-  data.tar.gz: 1ffb8d0777fce695e3d32833d9b221c6749c8d59951afb45625a167ab755377c16519848f578037fca5f5238d081dd313bbe81edd4ff52050ea55f443e57cfd0
+  metadata.gz: 84b0d946f58b584cc887f16078ca08f821d06674d97f5cce171bdf95336570b11d84a0829f83927ae4d7b38c3584e3b5c1432cf2cab3d742457339a78964fb8e
+  data.tar.gz: 395fd5968b5b5a8e9b4ce74cecb91b297463a9a31b6013593c0989d0f8e175fb27fa82800592941928d8b067d8f3b67d17531208ac4a1168ae293ef03534a3e8

data/lib/coverage_reporter/coverage_analyzer.rb

@@ -6,8 +6,8 @@ module CoverageReporter
   #
   # @param uncovered_ranges [Hash] Uncovered data where:
   #   - Keys are filenames (e.g., "app/models/user.rb")
-  #   - Values are arrays of ranges representing uncovered lines
-  #   - Example: { "app/models/user.rb" => [[12,14],[29,30]] }
+  #   - Values are hashes with :actual_ranges and :display_ranges
+  #   - Example: { "app/models/user.rb" => { actual_ranges: [[12,14],[29,30]], display_ranges: [[12,15],[29,30]] } }
   #
   # @param modified_ranges [Hash] Modified data where:
   #   - Keys are filenames (e.g., "app/models/user.rb")
@@ -22,24 +22,23 @@ module CoverageReporter
     def call
       logger.debug("Starting coverage analysis for #{@modified_ranges.size} modified files")
 
-      intersections = {}
-      total_modified_lines = 0
-      total_uncovered_modified_lines = 0
+      accumulator = initialize_accumulator
 
       @modified_ranges.each do |file, modified_ranges|
-        next if modified_ranges.nil? || modified_ranges.empty?
+        next if skip_file?(modified_ranges)
+        next unless file_has_coverage_data?(file)
 
         file_result = process_file(file, modified_ranges)
-        intersections.merge!(file_result[:intersections])
-        total_modified_lines += file_result[:modified_lines]
-        total_uncovered_modified_lines += file_result[:uncovered_lines]
+        merge_file_result(accumulator, file_result)
       end
 
-      coverage_percentage = calculate_percentage(total_modified_lines, total_uncovered_modified_lines)
-
-      log_results(intersections, total_modified_lines, total_uncovered_modified_lines, coverage_percentage)
+      coverage_percentage = calculate_percentage(
+        accumulator[:total_modified_lines],
+        accumulator[:total_uncovered_modified_lines]
+      )
 
-      build_result(intersections, total_modified_lines, total_uncovered_modified_lines, coverage_percentage)
+      log_results(accumulator, coverage_percentage)
+      build_result(accumulator, coverage_percentage)
     end
 
     private
@@ -48,100 +47,155 @@ module CoverageReporter
       CoverageReporter.logger
     end
 
-    def process_file(file, modified_ranges)
-      # Calculate intersection for inline comments
-      uncovered_ranges = @uncovered_ranges[file] || []
-      intersecting_ranges = intersect_ranges(modified_ranges, uncovered_ranges)
+    def initialize_accumulator
+      {
+        intersections:                  {},
+        total_modified_lines:           0,
+        total_uncovered_modified_lines: 0
+      }
+    end
 
-      # Calculate coverage statistics
-      file_modified_lines = count_lines_in_ranges(modified_ranges)
-      uncovered_modified_lines = count_intersecting_lines(modified_ranges, uncovered_ranges)
+    def skip_file?(modified_ranges)
+      modified_ranges.nil? || modified_ranges.empty?
+    end
+
+    def file_has_coverage_data?(file)
+      @uncovered_ranges.key?(file)
+    end
 
-      intersections = {}
-      # Only include files with actual intersections (matching original behavior)
-      intersections[file] = intersecting_ranges unless intersecting_ranges.empty?
+    def merge_file_result(accumulator, file_result)
+      accumulator[:intersections].merge!(file_result[:intersections])
+      accumulator[:total_modified_lines] += file_result[:modified_lines]
+      accumulator[:total_uncovered_modified_lines] += file_result[:uncovered_lines]
+    end
+
+    def process_file(file, modified_ranges)
+      file_data = @uncovered_ranges[file] || { actual_ranges: [], display_ranges: [] }
+      uncovered_ranges = file_data[:actual_ranges] || []
+      intersecting_ranges = find_intersecting_ranges(modified_ranges, uncovered_ranges)
 
       {
-        intersections:   intersections,
-        modified_lines:  file_modified_lines,
-        uncovered_lines: uncovered_modified_lines
+        intersections:   build_file_intersections(file, intersecting_ranges),
+        modified_lines:  count_lines_in_ranges(modified_ranges),
+        uncovered_lines: count_intersecting_lines(modified_ranges, uncovered_ranges)
       }
     end
 
-    def fibonacci(num)
-      return num if num <= 1
+    def build_file_intersections(file, intersecting_ranges)
+      return {} if intersecting_ranges.empty?
 
-      fibonacci(num - 1) + fibonacci(num - 2)
+      { file => intersecting_ranges }
     end
 
-    def log_results(intersections, total_modified_lines, total_uncovered_modified_lines, coverage_percentage)
-      logger.debug("Identified modified uncovered intersection: #{intersections}")
-      logger.debug(
-        "Coverage calculation: #{total_modified_lines} total lines, " \
-        "#{total_uncovered_modified_lines} uncovered, #{coverage_percentage}% covered"
-      )
+    def find_intersecting_ranges(modified_ranges, uncovered_ranges)
+      return [] if uncovered_ranges.empty?
+
+      result = []
+      modified_index = 0
+      uncovered_index = 0
+
+      while modified_index < modified_ranges.size && uncovered_index < uncovered_ranges.size
+        modified_range = modified_ranges[modified_index]
+        uncovered_range = uncovered_ranges[uncovered_index]
+
+        intersection = calculate_range_intersection(modified_range, uncovered_range)
+        result << intersection if intersection
+
+        modified_index, uncovered_index = advance_indices(
+          modified_range,
+          uncovered_range,
+          modified_index,
+          uncovered_index
+        )
+      end
+
+      result
     end
 
-    def build_result(intersections, total_modified_lines, total_uncovered_modified_lines, coverage_percentage)
-      {
-        intersections:  intersections,
-        coverage_stats: {
-          total_modified_lines:     total_modified_lines,
-          uncovered_modified_lines: total_uncovered_modified_lines,
-          covered_modified_lines:   total_modified_lines - total_uncovered_modified_lines,
-          coverage_percentage:      coverage_percentage
-        }
-      }
+    def calculate_range_intersection(range1, range2)
+      start1, end1 = range1
+      start2, end2 = range2
+
+      intersection_start = [start1, start2].max
+      intersection_end = [end1, end2].min
+
+      return nil if intersection_start > intersection_end
+
+      [intersection_start, intersection_end]
     end
 
-    def count_lines_in_ranges(ranges)
-      ranges.sum { |range| range[1] - range[0] + 1 }
+    def advance_indices(modified_range, uncovered_range, modified_index, uncovered_index)
+      modified_end = modified_range[1]
+      uncovered_end = uncovered_range[1]
+
+      if modified_end < uncovered_end
+        [modified_index + 1, uncovered_index]
+      else
+        [modified_index, uncovered_index + 1]
+      end
     end
 
     def count_intersecting_lines(modified_ranges, uncovered_ranges)
       return 0 if uncovered_ranges.empty?
 
-      intersecting_lines = 0
-      i = j = 0
+      total_lines = 0
+      modified_index = 0
+      uncovered_index = 0
 
-      while i < modified_ranges.size && j < uncovered_ranges.size
-        modified_start, modified_end = modified_ranges[i]
-        uncovered_start, uncovered_end = uncovered_ranges[j]
+      while modified_index < modified_ranges.size && uncovered_index < uncovered_ranges.size
+        modified_range = modified_ranges[modified_index]
+        uncovered_range = uncovered_ranges[uncovered_index]
 
-        # Find intersection
-        intersection_start = [modified_start, uncovered_start].max
-        intersection_end = [modified_end, uncovered_end].min
+        intersection = calculate_range_intersection(modified_range, uncovered_range)
+        total_lines += count_lines_in_range(intersection) if intersection
 
-        intersecting_lines += intersection_end - intersection_start + 1 if intersection_start <= intersection_end
-
-        # Move to next range
-        if modified_end < uncovered_end
-          i += 1
-        else
-          j += 1
-        end
+        modified_index, uncovered_index = advance_indices(
+          modified_range,
+          uncovered_range,
+          modified_index,
+          uncovered_index
+        )
       end
 
-      intersecting_lines
+      total_lines
     end
 
-    # rubocop:disable Metrics/AbcSize
-    def intersect_ranges(changed, uncovered)
-      i = j = 0
-      result = []
-      while i < changed.size && j < uncovered.size
-        s = [changed[i][0], uncovered[j][0]].max
-        e = [changed[i][1], uncovered[j][1]].min
-        result << [s, e] if s <= e
-        if changed[i][1] < uncovered[j][1]
-          i += 1
-        else
-          j += 1
-        end
-      end
-      result
+    def count_lines_in_ranges(ranges)
+      ranges.sum { |range| count_lines_in_range(range) }
+    end
+
+    def count_lines_in_range(range)
+      start_line, end_line = range
+      end_line - start_line + 1
+    end
+
+    def log_results(accumulator, coverage_percentage)
+      logger.debug("Identified modified uncovered intersection: #{accumulator[:intersections]}")
+      logger.debug(
+        "Coverage calculation: #{accumulator[:total_modified_lines]} total lines, " \
+        "#{accumulator[:total_uncovered_modified_lines]} uncovered, " \
+        "#{coverage_percentage}% covered"
+      )
+    end
+
+    def build_result(accumulator, coverage_percentage)
+      {
+        intersections:  accumulator[:intersections],
+        coverage_stats: build_coverage_stats(accumulator, coverage_percentage)
+      }
+    end
+
+    def build_coverage_stats(accumulator, coverage_percentage)
+      total_modified_lines = accumulator[:total_modified_lines]
+      uncovered_modified_lines = accumulator[:total_uncovered_modified_lines]
+
+      {
+        total_modified_lines:     total_modified_lines,
+        uncovered_modified_lines: uncovered_modified_lines,
+        covered_modified_lines:   total_modified_lines - uncovered_modified_lines,
+        coverage_percentage:      coverage_percentage
+      }
     end
-    # rubocop:enable Metrics/AbcSize
 
     def calculate_percentage(total_lines, uncovered_lines)
       return 100.0 if total_lines == 0

data/lib/coverage_reporter/coverage_collator.rb

@@ -19,16 +19,19 @@ module CoverageReporter
       coverage_files = Dir["#{coverage_dir}/resultset-*.json"]
       abort "No coverage JSON files found to collate" if coverage_files.empty?
 
-      puts "Collate coverage files: #{coverage_files.join(', ')}"
+      logger.debug("Collate coverage files: #{coverage_files.join(', ')}")
+      logger.debug("Working directory: #{working_dir}")
+      logger.debug("Filenames: #{filenames}")
 
       ::SimpleCov.root(working_dir) if working_dir
 
       ::SimpleCov.collate(coverage_files) do
+        filters.clear
         add_filter(build_filter) if filenames.any? && working_dir
         formatter(build_formatter)
       end
 
-      puts "✅ Coverage merged and report generated."
+      logger.info("✅ Coverage merged and report generated.")
     end
     # rubocop:enable Metrics/AbcSize
 
@@ -36,6 +39,10 @@ module CoverageReporter
 
     attr_reader :coverage_dir, :filenames, :working_dir
 
+    def logger
+      CoverageReporter.logger
+    end
+
     def build_formatter
       ::SimpleCov::Formatter::MultiFormatter.new(
         [
@@ -47,7 +54,7 @@ module CoverageReporter
 
     def build_filter
       lambda do |src_file|
-        normalized_filename = src_file.filename.gsub(working_dir, "").gsub(%r{^/}, "")
+        normalized_filename = src_file.filename.delete_prefix(working_dir).delete_prefix("/")
         filenames.none?(normalized_filename)
       end
     end

data/lib/coverage_reporter/global_comment.rb

@@ -19,7 +19,7 @@ module CoverageReporter
         <!-- coverage-comment-marker -->
         **Test Coverage Summary**
 
-        #{coverage_percentage < 100 ? '❌' : '✅'} **#{coverage_percentage}%** of changed lines are covered.
+        #{coverage_percentage < 100 ? '❌' : '✅'} **#{coverage_percentage}%** of relevant modified lines are covered.
 
         [View full report](#{report_url})
 

data/lib/coverage_reporter/uncovered_ranges_extractor.rb

@@ -7,15 +7,15 @@ module CoverageReporter
     end
 
     def call
-      coverage_map = Hash.new { |h, k| h[k] = [] }
+      coverage_map = {}
 
       return coverage_map unless coverage
 
       coverage.each do |filename, data|
         # Remove leading slash from file paths for consistency
-        normalized_filename = filename.start_with?("/") ? filename[1..] : filename
-        uncovered_ranges = extract_uncovered_ranges(data["lines"])
-        coverage_map[normalized_filename] = uncovered_ranges
+        normalized_filename = filename.delete_prefix("/")
+        ranges = extract_uncovered_ranges(data["lines"])
+        coverage_map[normalized_filename] = ranges
       end
 
       coverage_map
@@ -30,46 +30,60 @@ module CoverageReporter
     end
 
     def extract_uncovered_ranges(lines)
-      return [] unless lines.is_a?(Array)
+      return { actual_ranges: [], display_ranges: [] } unless lines.is_a?(Array)
 
-      uncovered_lines = []
+      actual_uncovered_lines = []
+      display_uncovered_lines = []
       i = 0
 
       while i < lines.length
         if lines[i] == 0
-          i = process_uncovered_range(lines, uncovered_lines, i)
+          i = process_uncovered_range(lines, actual_uncovered_lines, display_uncovered_lines, i)
         else
           i += 1
         end
       end
 
-      convert_to_ranges(uncovered_lines)
+      {
+        actual_ranges:  convert_to_ranges(actual_uncovered_lines),
+        display_ranges: convert_to_ranges(display_uncovered_lines)
+      }
     end
 
-    def process_uncovered_range(lines, uncovered_lines, start_index)
+    def process_uncovered_range(lines, actual_lines, display_lines, start_index)
       i = start_index
       # Found an uncovered line, start a range (always starts with 0)
-      uncovered_lines << (i + 1)
+      line_number = i + 1
+      actual_lines << line_number
+      display_lines << line_number
       i += 1
 
       # Continue through consecutive 0s and nils
       # Include nil only if it's immediately followed by an uncovered line (0)
-      continue_uncovered_range(lines, uncovered_lines, i)
+      continue_uncovered_range(lines, actual_lines, display_lines, i)
     end
 
-    def continue_uncovered_range(lines, uncovered_lines, start_index)
+    def continue_uncovered_range(lines, actual_lines, display_lines, start_index)
       i = start_index
       while i < lines.length
-        break unless should_continue_range?(lines, i)
-
-        uncovered_lines << (i + 1)
-        i += 1
+        line_number = i + 1
+        if lines[i] == 0
+          # Actual uncovered line - add to both
+          actual_lines << line_number
+          display_lines << line_number
+          i += 1
+        elsif lines[i].nil? && should_continue_range?(lines, i)
+          # Nil line that continues the range - add only to display
+          display_lines << line_number
+          i += 1
+        else
+          break
+        end
       end
       i
     end
 
     def should_continue_range?(lines, index)
-      return true if lines[index] == 0
       return false unless lines[index].nil?
 
       # Include nil only if it's immediately followed by an uncovered line (0)

data/lib/coverage_reporter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CoverageReporter
-  VERSION = "0.3.3"
+  VERSION = "0.3.4"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: coverage-reporter
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Gabriel Taylor Russ
 bindir: exe
 cert_chain: []
-date: 2025-11-17 00:00:00.000000000 Z
+date: 2025-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: octokit