coverage-reporter 0.1.0 → 0.3.0

data/lib/coverage_reporter/inline_comment_poster.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "set"
+
+module CoverageReporter
+  class InlineCommentPoster
+    def initialize(pull_request:, commit_sha:, inline_comments:)
+      @pull_request = pull_request
+      @commit_sha = commit_sha
+      @updated_comment_ids = Set.new
+      @inline_comments = inline_comments
+      @existing_coverage_comments = {}
+    end
+
+    def call
+      retrieve_existing_coverage_comments
+
+      inline_comments.each do |comment|
+        logger.info("Posting inline comment for #{comment.path}: #{comment.start_line}–#{comment.line}")
+        post_comment(comment)
+      end
+
+      cleanup_stale_comments
+    end
+
+    private
+
+    attr_reader :pull_request, :commit_sha, :updated_comment_ids, :inline_comments, :existing_coverage_comments
+
+    def logger
+      CoverageReporter.logger
+    end
+
+    def retrieve_existing_coverage_comments
+      logger.debug("Recording existing coverage comments")
+      @existing_coverage_comments = pull_request
+        .inline_comments
+        .filter { |comment| coverage_comment?(comment) }
+        .to_h do |comment|
+          logger.debug("Found existing coverage comment: #{comment.id} for #{comment.path}:#{comment.start_line}-#{comment.line}")
+          [comment.id, comment]
+        end
+    end
+
+    def cleanup_stale_comments
+      comment_ids_to_delete = existing_coverage_comments.keys - updated_comment_ids.to_a
+
+      if comment_ids_to_delete.any?
+        logger.debug("Cleaning up #{comment_ids_to_delete.size} unused coverage comments")
+
+        comment_ids_to_delete.each do |comment_id|
+          logger.info("Deleting stale coverage comment: #{comment_id}")
+          pull_request.delete_inline_comment(comment_id)
+        end
+      else
+        logger.debug("No stale coverage comments to clean up")
+      end
+    end
+
+    def coverage_comment?(comment)
+      comment.body&.include?(INLINE_COMMENT_MARKER)
+    end
+
+    def post_comment(comment)
+      existing_comment = existing_comment_for_path_and_lines(comment.path, comment.start_line, comment.line)
+
+      if existing_comment
+        pull_request.update_inline_comment(id: existing_comment.id, body: comment.body)
+        updated_comment_ids.add(existing_comment.id)
+      else
+        pull_request.add_comment_on_lines(
+          commit_id:  commit_sha,
+          path:       comment.path,
+          start_line: comment.start_line,
+          line:       comment.line,
+          body:       comment.body
+        )
+      end
+    end
+
+    def existing_comment_for_path_and_lines(path, start_line, line)
+      existing_coverage_comments.values.find do |comment|
+        if line == start_line
+          comment.path == path && comment.line == line
+        else
+          comment.path == path && comment.start_line == start_line && comment.line == line
+        end
+      end
+    end
+  end
+end

data/lib/coverage_reporter/modified_ranges_extractor.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module CoverageReporter
+  class ModifiedRangesExtractor
+    HUNK_HEADER = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/
+
+    def initialize(diff_text)
+      @diff_text = diff_text
+    end
+
+    def call
+      return {} unless @diff_text
+
+      parse_diff(@diff_text)
+    rescue StandardError
+      {}
+    end
+
+    private
+
+    def parse_diff(text)
+      changed = Hash.new { |h, k| h[k] = [] }
+      current_file = nil
+      current_new_line = nil
+
+      text.each_line do |raw_line|
+        line = raw_line.chomp
+
+        if file_header_line?(line)
+          current_file = parse_new_file_path(line)
+          next
+        end
+
+        if (m = hunk_header_match(line))
+          current_new_line = m[1].to_i
+          next
+        end
+
+        next unless current_file && current_new_line
+
+        current_new_line = process_content_line(line, changed, current_file, current_new_line)
+      end
+
+      # Convert arrays of line numbers to ranges
+      changed.transform_values { |arr| consolidate_to_ranges(arr.uniq.sort) }
+    end
+
+    def file_header_line?(line)
+      line.start_with?("+++ ")
+    end
+
+    def hunk_header_match(line)
+      HUNK_HEADER.match(line)
+    end
+
+    def process_content_line(line, changed, current_file, current_new_line)
+      case line[0]
+      when "+"
+        handle_added_line(line, changed, current_file, current_new_line)
+      when "-"
+        current_new_line
+      when " "
+        current_new_line + 1
+      end
+    end
+
+    def handle_added_line(line, changed, current_file, current_new_line)
+      return current_new_line if line.start_with?("+++ ")
+
+      changed[current_file] << current_new_line
+      current_new_line + 1
+    end
+
+    def parse_new_file_path(line)
+      return nil if line.end_with?(File::NULL)
+
+      if (m = line.match(%r{\A\+\+\+\s[wb]/(.+)\z}))
+        m[1]
+      end
+    end
+
+    def consolidate_to_ranges(line_numbers)
+      return [] if line_numbers.empty?
+
+      ranges = []
+      start = line_numbers.first
+      last = line_numbers.first
+
+      line_numbers.each_cons(2) do |current, next_line|
+        if next_line == current + 1
+          # Consecutive line, extend current range
+          last = next_line
+        else
+          # Gap found, close current range and start new one
+          ranges << [start, last]
+          start = next_line
+          last = next_line
+        end
+      end
+
+      # Add the final range
+      ranges << [start, last]
+      ranges
+    end
+  end
+end

data/lib/coverage_reporter/options/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module CoverageReporter
+  module Options
+    # Interface class that defines the contract for option classes
+    class Base
+      # Returns a hash of default options
+      def self.defaults
+        raise NotImplementedError, "Subclasses must implement #{__method__}"
+      end
+
+      # Parses command line arguments and returns a hash of options
+      # @param argv [Array<String>] Command line arguments
+      # @return [Hash] Parsed options
+      def self.parse(argv)
+        raise NotImplementedError, "Subclasses must implement #{__method__}"
+      end
+    end
+  end
+end

data/lib/coverage_reporter/options/collate.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module CoverageReporter
+  module Options
+    class Collate < Base
+      def self.defaults
+        {
+          coverage_dir: "coverage"
+        }
+      end
+
+      def self.parse(argv)
+        opts = defaults.dup
+
+        parser = OptionParser.new do |o|
+          o.banner = "Usage: coverage-reporter collate [options]"
+          o.on("--coverage-dir DIR", "Directory containing coverage files (default: coverage)") do |v|
+            opts[:coverage_dir] = v
+          end
+          o.on_tail("-h", "--help", "Show help") do
+            puts o
+            exit 0
+          end
+        end
+
+        parser.parse!(argv)
+        opts
+      end
+    end
+  end
+end

data/lib/coverage_reporter/options/report.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module CoverageReporter
+  module Options
+    class Report < Base
+      def self.defaults
+        {
+          commit_sha:           ENV.fetch("COMMIT_SHA", nil),
+          coverage_report_path: ENV.fetch("COVERAGE_REPORT_PATH", "coverage/coverage.json"),
+          github_token:         ENV.fetch("GITHUB_TOKEN", nil),
+          pr_number:            ENV.fetch("PR_NUMBER", nil),
+          repo:                 normalize_repo(ENV.fetch("REPO", nil)),
+          report_url:           ENV.fetch("REPORT_URL", nil)
+        }
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def self.parse(argv)
+        opts = defaults.dup
+
+        parser = OptionParser.new do |o|
+          o.banner = "Usage: coverage-reporter [options]"
+          o.on("--report-url URL", "Report URL used for links (default: $REPORT_URL)") do |v|
+            opts[:report_url] = v
+          end
+          o.on("--commit-sha SHA", "GitHub commit SHA (default: $COMMIT_SHA)") do |v|
+            opts[:commit_sha] = v
+          end
+          o.on(
+            "--coverage-report-path PATH",
+            "Path to merged SimpleCov coverage.json (default: coverage/coverage.json)"
+          ) do |v|
+            opts[:coverage_report_path] = v
+          end
+          o.on("--github-token TOKEN", "GitHub token (default: $GITHUB_TOKEN)") { |v| opts[:github_token] = v }
+          o.on("--pr-number NUMBER", "GitHub pull request number (default: $PR_NUMBER)") do |v|
+            opts[:pr_number] = v
+          end
+          o.on("--repo REPO", "GitHub repository (default: $REPO)") do |v|
+            opts[:repo] = normalize_repo(v)
+          end
+          o.on_tail("-h", "--help", "Show help") do
+            puts o
+            exit 0
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/MethodLength
+        parser.parse!(argv)
+
+        validate!(opts)
+        opts
+      end
+
+      def self.validate!(opts)
+        missing = collect_missing_options(opts)
+        return if missing.empty?
+
+        abort "coverage-reporter: missing required option(s): #{missing.join(', ')}"
+      end
+
+      def self.collect_missing_options(opts)
+        required_options = {
+          github_token: "--github-token or $GITHUB_TOKEN",
+          repo:         "--repo or $REPO",
+          pr_number:    "--pr-number or $PR_NUMBER",
+          commit_sha:   "--commit-sha or $COMMIT_SHA"
+        }
+
+        required_options.filter_map do |key, message|
+          message if opts[key].to_s.strip.empty?
+        end
+      end
+
+      def self.normalize_repo(repo)
+        return repo if repo.nil? || repo.strip.empty?
+
+        repo.strip
+          .gsub(%r{^(https://github\.com/|git@github\.com:)}, "")
+          .gsub(/\.git$/, "")
+      end
+    end
+  end
+end

data/lib/coverage_reporter/pull_request.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module CoverageReporter
+  class PullRequest
+    def initialize(github_token:, repo:, pr_number:)
+      opts = { access_token: github_token }
+
+      @client = ::Octokit::Client.new(**opts)
+      @client.auto_paginate = true
+      @repo = repo
+      @pr_number = pr_number
+    end
+
+    def latest_commit_sha
+      @latest_commit_sha ||= client.pull_request(repo, pr_number).head.sha
+    end
+
+    # get global comments
+    def global_comments
+      client.issue_comments(repo, pr_number)
+    end
+
+    # add global comment
+    def add_global_comment(body:)
+      client.add_comment(repo, pr_number, body)
+    end
+
+    # update global comment
+    def update_global_comment(id:, body:)
+      client.update_comment(repo, id, body)
+    end
+
+    # delete global comment
+    def delete_global_comment(id)
+      client.delete_comment(repo, id)
+    end
+
+    # get inline comments
+    def inline_comments
+      client.pull_request_comments(repo, pr_number)
+    end
+
+    # update inline comment
+    def update_inline_comment(id:, body:)
+      client.update_pull_request_comment(repo, id, body)
+    end
+
+    # delete inline comment
+    def delete_inline_comment(id)
+      client.delete_pull_request_comment(repo, id)
+    end
+
+    def add_comment_on_lines(commit_id:, path:, start_line:, line:, body:)
+      payload = build_comment_payload(body:, commit_id:, path:, start_line:, line:)
+      create_comment_with_error_handling(payload)
+    end
+
+    def diff
+      @diff ||= client.pull_request(repo, pr_number, accept: "application/vnd.github.v3.diff")
+    end
+
+    private
+
+    attr_reader :client, :repo, :pr_number
+
+    def logger
+      CoverageReporter.logger
+    end
+
+    def build_comment_payload(body:, commit_id:, path:, start_line:, line:)
+      payload = {
+        body:      body,
+        commit_id: commit_id,
+        path:      path,
+        side:      "RIGHT"
+      }
+
+      if start_line && line > start_line
+        payload[:line] = line
+        payload[:start_line] = start_line
+      elsif start_line == line
+        payload[:line] = line
+      end
+
+      payload
+    end
+
+    def create_comment_with_error_handling(payload)
+      client.post("/repos/#{repo}/pulls/#{pr_number}/comments", payload)
+    rescue Octokit::Error => e
+      handle_github_api_error(e, payload)
+    end
+
+    def handle_github_api_error(error, payload)
+      logger.error("GitHub API Error: #{error.message}")
+      logger.error("Payload: #{payload.inspect}")
+      raise
+    end
+  end
+end

data/lib/coverage_reporter/runner.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module CoverageReporter
+  class Runner
+    def initialize(options)
+      @commit_sha           = options[:commit_sha]
+      @coverage_report_path = options[:coverage_report_path]
+      @github_token         = options[:github_token]
+      @report_url           = options[:report_url]
+      @repo                 = options[:repo]
+      @pr_number            = options[:pr_number]
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def run
+      pull_request = PullRequest.new(github_token:, repo:, pr_number:)
+      coverage_report = CoverageReportLoader.new(coverage_report_path).call
+      modified_ranges = ModifiedRangesExtractor.new(pull_request.diff).call
+      uncovered_ranges = UncoveredRangesExtractor.new(coverage_report).call
+      analysis_result = CoverageAnalyzer.new(uncovered_ranges:, modified_ranges:).call
+      intersection = analysis_result[:intersections]
+      coverage_stats = analysis_result[:coverage_stats]
+      inline_comments = InlineCommentFactory.new(intersection:, commit_sha:).call
+      InlineCommentPoster.new(pull_request:, commit_sha:, inline_comments:).call
+      global_comment = GlobalComment.new(
+        commit_sha:,
+        report_url:,
+        coverage_percentage: coverage_stats[:coverage_percentage],
+        intersections:       intersection
+      )
+      GlobalCommentPoster.new(pull_request:, global_comment:).call
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    private
+
+    attr_reader :coverage_report_path, :github_token, :report_url, :repo, :pr_number, :commit_sha
+  end
+end

data/lib/coverage_reporter/simple_cov/patches/result_hash_formatter_patch.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "simplecov_json_formatter"
+
+module CoverageReporter
+  module SimpleCov
+    module Patches
+      module ResultHashFormatterPatch
+        def self.included(base)
+          base.class_eval do
+            private
+
+            def format_files
+              @result.files.each do |source_file|
+                # Use project_filename instead of filename to get the relative path
+                formatted_result[:coverage][source_file.project_filename] = format_source_file(source_file)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+SimpleCovJSONFormatter::ResultHashFormatter.include(CoverageReporter::SimpleCov::Patches::ResultHashFormatterPatch)

data/lib/coverage_reporter/uncovered_ranges_extractor.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module CoverageReporter
+  class UncoveredRangesExtractor
+    def initialize(coverage_report)
+      @coverage_report = coverage_report
+    end
+
+    def call
+      coverage_map = Hash.new { |h, k| h[k] = [] }
+
+      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
+      end
+
+      coverage_map
+    end
+
+    private
+
+    def coverage
+      return nil unless @coverage_report.is_a?(Hash)
+
+      @coverage_report["coverage"]
+    end
+
+    def extract_uncovered_ranges(lines)
+      return [] unless lines.is_a?(Array)
+
+      uncovered_lines = []
+      lines.each_with_index do |count, idx|
+        # Only lines with 0 count are considered uncovered
+        # null values are not relevant for coverage
+        uncovered_lines << (idx + 1) if count == 0
+      end
+      convert_to_ranges(uncovered_lines)
+    end
+
+    def convert_to_ranges(lines)
+      return [] if lines.empty?
+
+      ranges = []
+      start_line = lines.first
+      end_line = lines.first
+
+      lines.each_cons(2) do |current, next_line|
+        if next_line == current + 1
+          # Consecutive lines, extend the range
+          end_line = next_line
+        else
+          # Gap found, close current range and start new one
+          ranges << [start_line, end_line]
+          start_line = next_line
+          end_line = next_line
+        end
+      end
+
+      # Add the last range
+      ranges << [start_line, end_line]
+      ranges
+    end
+  end
+end

data/lib/coverage_reporter/version.rb

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

data/lib/coverage_reporter.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "logger"
+require "octokit"
+
+module CoverageReporter
+  # Comment markers for identifying coverage-related comments
+  INLINE_COMMENT_MARKER = "<!-- coverage-inline-marker -->"
+  GLOBAL_COMMENT_MARKER = "<!-- coverage-comment-marker -->"
+
+  autoload :CLI, "coverage_reporter/cli"
+  autoload :VERSION, "coverage_reporter/version"
+
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger ||= Logger.new($stdout).tap do |log|
+        log.progname = name
+        log.level = valid_log_level(ENV.fetch("COVERAGE_REPORTER_LOG_LEVEL", nil))
+      end
+    end
+
+    private
+
+    def valid_log_level(env_level)
+      return "INFO" if env_level.nil? || env_level.empty?
+
+      level = env_level.upcase
+      valid_levels = %w[DEBUG INFO WARN ERROR]
+
+      valid_levels.include?(level) ? level : "INFO"
+    end
+  end
+
+  require_relative "coverage_reporter/coverage_analyzer"
+  require_relative "coverage_reporter/coverage_collator"
+  require_relative "coverage_reporter/coverage_report_loader"
+  require_relative "coverage_reporter/global_comment"
+  require_relative "coverage_reporter/global_comment_poster"
+  require_relative "coverage_reporter/inline_comment"
+  require_relative "coverage_reporter/inline_comment_factory"
+  require_relative "coverage_reporter/inline_comment_poster"
+  require_relative "coverage_reporter/modified_ranges_extractor"
+  require_relative "coverage_reporter/options/base"
+  require_relative "coverage_reporter/options/collate"
+  require_relative "coverage_reporter/options/report"
+  require_relative "coverage_reporter/pull_request"
+  require_relative "coverage_reporter/runner"
+  require_relative "coverage_reporter/uncovered_ranges_extractor"
+  require_relative "coverage_reporter/simple_cov/patches/result_hash_formatter_patch"
+end

data/lib/tasks/coverage.rake

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+namespace :coverage do
+  desc "Merge coverage reports"
+  task :collate do
+    require "simplecov"
+    require "simplecov_json_formatter"
+    require "coverage_reporter/simple_cov/patches/result_hash_formatter_patch"
+
+    # Collate JSON coverage reports and generate both HTML and JSON outputs
+    files = Dir["coverage/resultset-*.json"]
+    abort "No coverage JSON files found to collate" if files.empty?
+    puts "Collate coverage files: #{files.join(', ')}"
+    SimpleCov.collate(files) do
+      formatter SimpleCov::Formatter::MultiFormatter.new(
+        [
+          SimpleCov::Formatter::HTMLFormatter,
+          SimpleCov::Formatter::JSONFormatter
+        ]
+      )
+    end
+
+    puts "✅ Coverage merged and report generated."
+  end
+end