coverage-reporter 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 502fcd527b9376d80aa547f7d416fc6159c610c3806aee89b1ee47bf65b0d586
-  data.tar.gz: 90d60ffe2f23649fa8efa86603761ad3985eb5d623c81b9e80b782320682d0cc
+  metadata.gz: c646220bc7af144054d14538534b4fdc0ee3dc6a0f0e3bcea0b26bf1611a9839
+  data.tar.gz: 644b7b1431164971025b9f5e2dcfd0d25a9ce9164764e76341080d597816be17
 SHA512:
-  metadata.gz: 004ef1c9498a942deb8514942fc91764a49aa24c70ba3186efbceb1ed4554b935837f857735df18a6900fda0c7916fca245fd2d555002913ca17b8dd596a671e
-  data.tar.gz: cd2007eaaa1eb78cd342c8ff43538d2878ca3fe756432b212b0534e0338fc7be02800ef26243ecf06911f3e10efebba5c85e9567bcf9b74353310032432ee157
+  metadata.gz: '089653dbdbdb8d9ff0321afdfc4fd5c01765045f51a949f2f37e08677f540dd10e1ed2a5b977edb81b0cf111ed78e7943de246977ca21c9c194cdc06e5a55b88'
+  data.tar.gz: 4c7e4d2379a58d932a6b06387b53a0e114b58b7124ad0a2f7ed4e64aef22e6e1a3170cefa4ec9d58d64356c42a122a686a7f322113134f2e2d6687824b6d313a

data/README.md

@@ -3,35 +3,204 @@
 [![Gem Version](https://img.shields.io/gem/v/coverage-reporter)](https://rubygems.org/gems/coverage-reporter)
 [![Gem Downloads](https://img.shields.io/gem/dt/coverage-reporter)](https://www.ruby-toolbox.com/projects/coverage-reporter)
 [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/gabrieltaylor/coverage-reporter/ci.yml)](https://github.com/gabrieltaylor/coverage-reporter/actions/workflows/ci.yml)
-[![Code Climate maintainability](https://img.shields.io/codeclimate/maintainability/gabrieltaylor/coverage-reporter)](https://codeclimate.com/github/gabrieltaylor/coverage-reporter)
 
-Report code coverage from SimpleCov coverage reports to a Github pull request.
+Report code coverage from SimpleCov coverage reports to a GitHub pull request. This tool analyzes your test coverage data and posts detailed comments on pull requests, highlighting uncovered lines in modified code.
 
 ---
 
-- [Quick start](#quick-start)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Configuration](#configuration)
+- [Usage Examples](#usage-examples)
+- [CI/CD Integration](#cicd-integration)
+- [Command Line Options](#command-line-options)
+- [Environment Variables](#environment-variables)
+- [How It Works](#how-it-works)
 - [License](#license)
-- [Code of conduct](#code-of-conduct)
-- [Contribution guide](#contribution-guide)
+- [Code of Conduct](#code-of-conduct)
+- [Contributing](#contributing)
 
-## Quick start
+## Installation
 
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'coverage-reporter'
+```
+
+And then execute:
+
+```bash
+bundle install
 ```
+
+Or install it directly:
+
+```bash
 gem install coverage-reporter
 ```
 
-```ruby
-require "coverage-reporter"
+## Quick Start
+
+1. **Generate a SimpleCov coverage report** in your test suite:
+   ```ruby
+   # In your test helper or spec_helper
+   require 'simplecov'
+   SimpleCov.start
+   ```
+
+2. **Set up environment variables**:
+   ```bash
+   export GITHUB_TOKEN="your_github_token_here"
+   export REPO="owner/repository"
+   export PR_NUMBER="123"
+   export COMMIT_SHA="abc123def456"
+   ```
+
+3. **Run the coverage reporter**:
+   ```bash
+   coverage-reporter
+   ```
+
+The tool will automatically:
+- Load your coverage data from `coverage/coverage.json`
+- Fetch the pull request diff from GitHub
+- Identify uncovered lines in modified code
+- Post inline comments on uncovered lines
+- Add a global coverage summary comment
+
+## Configuration
+
+### Required Settings
+
+- **GitHub Token**: A personal access token with `repo` permissions
+- **Repository**: GitHub repository in `owner/repo` format
+- **Pull Request Number**: The PR number to comment on
+- **Commit SHA**: The commit SHA being analyzed
+
+### Optional Settings
+
+- **Coverage Report Path**: Path to your SimpleCov coverage.json file (default: `coverage/coverage.json`)
+- **Build URL**: CI build URL for linking back to your build (default: `$BUILD_URL`)
+
+## Usage Examples
+
+### Basic Usage
+
+```bash
+coverage-reporter \
+  --github-token "$GITHUB_TOKEN" \
+  --repo "myorg/myrepo" \
+  --pr-number "42" \
+  --commit-sha "$GITHUB_SHA"
+```
+
+### Custom Coverage Report Path
+
+```bash
+coverage-reporter \
+  --github-token "$GITHUB_TOKEN" \
+  --repo "myorg/myrepo" \
+  --pr-number "42" \
+  --commit-sha "$GITHUB_SHA" \
+  --coverage-report-path "test/coverage/coverage.json"
 ```
 
+### With Build URL
+
+```bash
+coverage-reporter \
+  --github-token "$GITHUB_TOKEN" \
+  --repo "myorg/myrepo" \
+  --pr-number "42" \
+  --commit-sha "$GITHUB_SHA" \
+  --build-url "https://github.com/myorg/myrepo/actions/runs/123456"
+```
+
+## CI/CD Integration
+
+### GitHub Actions
+
+```yaml
+name: Test Coverage
+on: [pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.1
+          bundler-cache: true
+
+      - name: Run tests with coverage
+        run: bundle exec rspec
+        env:
+          COVERAGE: true
+
+      - name: Report coverage
+        run: bundle exec coverage-reporter
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          REPO: ${{ github.repository }}
+          PR_NUMBER: ${{ github.event.number }}
+          COMMIT_SHA: ${{ github.sha }}
+          BUILD_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+```
+
+## Command Line Options
+
+| Option | Description | Default | Environment Variable |
+|--------|-------------|---------|---------------------|
+| `--github-token TOKEN` | GitHub personal access token | `$GITHUB_TOKEN` | `GITHUB_TOKEN` |
+| `--repo REPO` | GitHub repository (owner/repo) | `$REPO` | `REPO` |
+| `--pr-number NUMBER` | Pull request number | `$PR_NUMBER` | `PR_NUMBER` |
+| `--commit-sha SHA` | Git commit SHA | `$COMMIT_SHA` | `COMMIT_SHA` |
+| `--coverage-report-path PATH` | Path to coverage.json | `coverage/coverage.json` | `COVERAGE_REPORT_PATH` |
+| `--build-url URL` | CI build URL for links | `$BUILD_URL` | `BUILD_URL` |
+| `--help` | Show help message | - | - |
+
+## Environment Variables
+
+All command-line options can be set via environment variables:
+
+```bash
+export GITHUB_TOKEN="ghp_xxxxxxxxxxxx"
+export REPO="myorg/myrepo"
+export PR_NUMBER="123"
+export COMMIT_SHA="abc123def456"
+export COVERAGE_REPORT_PATH="coverage/coverage.json"
+export BUILD_URL="https://ci.example.com/build/123"
+```
+
+## How It Works
+
+1. **Loads Coverage Data**: Reads SimpleCov's `coverage.json` file to understand which lines are covered by tests
+2. **Fetches PR Diff**: Retrieves the pull request diff from GitHub to identify modified lines
+3. **Finds Intersections**: Identifies uncovered lines that were modified in the PR
+4. **Posts Inline Comments**: Adds comments directly on uncovered lines in the diff
+5. **Creates Summary**: Posts a global comment with overall coverage statistics
+
+### GitHub Token Permissions
+
+Your GitHub token needs the following permissions:
+- `repo` (Full control of private repositories)
+- `public_repo` (Access public repositories)
+
+Create a token at: https://github.com/settings/tokens
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](LICENSE.txt).
 
-## Code of conduct
+## Code of Conduct
 
-Everyone interacting in this project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](CODE_OF_CONDUCT.md).
+Everyone interacting in this project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](CODE_OF_CONDUCT.md).
 
-## Contribution guide
+## Contributing
 
-Pull requests are welcome!
+Pull requests are welcome! Please read our [contribution guidelines](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.

data/exe/coverage-reporter

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift("#{__dir__}/../lib")
+
+require "coverage_reporter"
+
+CoverageReporter::CLI.start(ARGV)

data/lib/coverage_reporter/cli.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module CoverageReporter
+  class CLI
+    def self.start(argv)
+      options = Options.parse(argv)
+      Runner.new(options).run
+    end
+  end
+end

data/lib/coverage_reporter/coverage_analyzer.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module CoverageReporter
+  # Analyzes coverage data against diff data to find uncovered lines in changed code
+  # and calculates coverage statistics
+  #
+  # @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]] }
+  #
+  # @param modified_ranges [Hash] Modified data where:
+  #   - Keys are filenames (e.g., "app/models/user.rb")
+  #   - Values are arrays of arrays representing modified or new line ranges
+  #   - Example: { "app/services/foo.rb" => [[100,120]] }
+  class CoverageAnalyzer
+    def initialize(uncovered_ranges:, modified_ranges:)
+      @uncovered_ranges = uncovered_ranges
+      @modified_ranges = modified_ranges
+    end
+
+    def call
+      logger.debug("Starting coverage analysis for #{@modified_ranges.size} modified files")
+
+      intersections = {}
+      total_modified_lines = 0
+      total_uncovered_modified_lines = 0
+
+      @modified_ranges.each do |file, modified_ranges|
+        next if modified_ranges.nil? || modified_ranges.empty?
+
+        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]
+      end
+
+      coverage_percentage = calculate_percentage(total_modified_lines, total_uncovered_modified_lines)
+
+      log_results(intersections, total_modified_lines, total_uncovered_modified_lines, coverage_percentage)
+
+      build_result(intersections, total_modified_lines, total_uncovered_modified_lines, coverage_percentage)
+    end
+
+    private
+
+    def logger
+      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)
+
+      # Calculate coverage statistics
+      file_modified_lines = count_lines_in_ranges(modified_ranges)
+      uncovered_modified_lines = count_intersecting_lines(modified_ranges, uncovered_ranges)
+
+      intersections = {}
+      # Only include files with actual intersections (matching original behavior)
+      intersections[file] = intersecting_ranges unless intersecting_ranges.empty?
+
+      {
+        intersections:   intersections,
+        modified_lines:  file_modified_lines,
+        uncovered_lines: uncovered_modified_lines
+      }
+    end
+
+    def fibonacci(num)
+      return num if num <= 1
+
+      fibonacci(num - 1) + fibonacci(num - 2)
+    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"
+      )
+    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
+        }
+      }
+    end
+
+    def count_lines_in_ranges(ranges)
+      ranges.sum { |range| range[1] - range[0] + 1 }
+    end
+
+    def count_intersecting_lines(modified_ranges, uncovered_ranges)
+      return 0 if uncovered_ranges.empty?
+
+      intersecting_lines = 0
+      i = j = 0
+
+      while i < modified_ranges.size && j < uncovered_ranges.size
+        modified_start, modified_end = modified_ranges[i]
+        uncovered_start, uncovered_end = uncovered_ranges[j]
+
+        # Find intersection
+        intersection_start = [modified_start, uncovered_start].max
+        intersection_end = [modified_end, uncovered_end].min
+
+        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
+      end
+
+      intersecting_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
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def calculate_percentage(total_lines, uncovered_lines)
+      return 100.0 if total_lines == 0
+
+      covered_lines = total_lines - uncovered_lines
+      ((covered_lines.to_f / total_lines) * 100).round(2)
+    end
+  end
+end

data/lib/coverage_reporter/coverage_report_loader.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "json"
+
+module CoverageReporter
+  # Custom error classes for coverage file operations
+  class CoverageFileError < StandardError; end
+  class CoverageFileNotFoundError < CoverageFileError; end
+  class CoverageFileAccessError < CoverageFileError; end
+  class CoverageFileParseError < CoverageFileError; end
+
+  class CoverageReportLoader
+    def initialize(coverage_file_path)
+      @coverage_file_path = coverage_file_path
+    end
+
+    def call
+      content = read_file_content
+      parse_json_content(content)
+    rescue Errno::ENOENT
+      raise CoverageFileNotFoundError, "Coverage file not found: #{@coverage_file_path}"
+    rescue Errno::EACCES
+      raise CoverageFileAccessError, "Permission denied reading coverage file: #{@coverage_file_path}"
+    rescue JSON::ParserError => e
+      raise CoverageFileParseError, "Invalid JSON in coverage file #{@coverage_file_path}: #{e.message}"
+    rescue StandardError => e
+      raise CoverageFileError, "Unexpected error reading coverage file #{@coverage_file_path}: #{e.message}"
+    end
+
+    private
+
+    attr_reader :coverage_file_path
+
+    def read_file_content
+      File.read(@coverage_file_path)
+    end
+
+    def parse_json_content(content)
+      JSON.parse(content)
+    end
+  end
+end

data/lib/coverage_reporter/global_comment.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module CoverageReporter
+  class GlobalComment
+    def initialize(coverage_percentage:, commit_sha:, report_url: nil, intersections: {})
+      @coverage_percentage = coverage_percentage
+      @commit_sha = commit_sha
+      @report_url = report_url
+      @intersections = intersections
+      @body = build_body
+    end
+
+    attr_reader :coverage_percentage, :commit_sha, :report_url, :intersections, :body
+
+    private
+
+    def build_body
+      body = <<~MD
+        <!-- coverage-comment-marker -->
+        **Test Coverage Summary**
+
+        #{coverage_percentage < 100 ? '❌' : '✅'} **#{coverage_percentage}%** of changed lines are covered.
+
+        [View full report](#{report_url})
+
+        _Commit: #{commit_sha}_
+      MD
+
+      body += "\n\n#{coverage_summary_section}" if intersections.any?
+
+      body
+    end
+
+    def coverage_summary_section
+      <<~MD
+        **Coverage Summary**
+
+        | File | Uncovered Lines |
+        |------|----------------|
+        #{coverage_summary_table_rows}
+      MD
+    end
+
+    def coverage_summary_table_rows
+      intersections.map do |file, ranges|
+        formatted_ranges = ranges.map { |range| format_range(range) }.join(", ")
+        "| `#{file}` | #{formatted_ranges} |"
+      end.join("\n")
+    end
+
+    def format_range(range)
+      start_line, end_line = range
+      if start_line == end_line
+        start_line.to_s
+      else
+        "#{start_line}-#{end_line}"
+      end
+    end
+  end
+end

data/lib/coverage_reporter/global_comment_poster.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module CoverageReporter
+  class GlobalCommentPoster
+    def initialize(pull_request:, global_comment:)
+      @pull_request = pull_request
+      @global_comment = global_comment
+    end
+
+    def call
+      ensure_global_comment
+    end
+
+    private
+
+    attr_reader :pull_request, :global_comment
+
+    def ensure_global_comment
+      comments = pull_request.global_comments
+      existing = comments.find { |c| c.body&.include?(GLOBAL_COMMENT_MARKER) }
+
+      if existing
+        pull_request.update_global_comment(id: existing.id, body: global_comment.body)
+      else
+        pull_request.add_global_comment(body: global_comment.body)
+      end
+    end
+  end
+end

data/lib/coverage_reporter/inline_comment.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module CoverageReporter
+  class InlineComment
+    attr_reader :path, :start_line, :line, :body
+
+    def initialize(path:, start_line:, line:, body:)
+      @path = path
+      @start_line = start_line
+      @line = line
+      @body = body
+    end
+
+    def single_line?
+      start_line == line
+    end
+
+    def range?
+      !single_line?
+    end
+  end
+end

data/lib/coverage_reporter/inline_comment_factory.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module CoverageReporter
+  class InlineCommentFactory
+    def initialize(commit_sha:, intersection:)
+      @commit_sha = commit_sha
+      @intersection = intersection
+    end
+
+    def call
+      comments = []
+
+      @intersection.each do |path, ranges|
+        ranges.each do |start_line, line|
+          body = build_body(path:, start_line:, line:)
+
+          comments << InlineComment.new(
+            path:       path,
+            start_line: start_line,
+            line:       line,
+            body:       body
+          )
+        end
+      end
+
+      comments
+    end
+
+    private
+
+    attr_reader :commit_sha, :intersection
+
+    def build_body(path:, start_line:, line:)
+      message = build_message(start_line, line)
+      "#{INLINE_COMMENT_MARKER}\n#{message}\n\n_File: #{path}, line #{start_line}_\n_Commit: #{commit_sha}_"
+    end
+
+    def build_message(start_line, line)
+      if start_line == line
+        "❌ Line #{start_line} is not covered by tests."
+      else
+        "❌ Lines #{start_line}–#{line} are not covered by tests."
+      end
+    end
+  end
+end

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.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module CoverageReporter
+  class Options
+    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

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.2.0"
+end

data/lib/coverage_reporter.rb

@@ -0,0 +1,49 @@
+# 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_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"
+  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

metadata

@@ -1,24 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: coverage-reporter
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Gabriel Taylor Russ
 bindir: exe
 cert_chain: []
-date: 2025-08-10 00:00:00.000000000 Z
-dependencies: []
+date: 2025-10-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: octokit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov_json_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 email:
 - gabriel.taylor.russ@gmail.com
-executables: []
+executables:
+- coverage-reporter
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE.txt
 - README.md
-- lib/coverage/reporter.rb
-- lib/coverage/reporter/version.rb
+- exe/coverage-reporter
+- lib/coverage_reporter.rb
+- lib/coverage_reporter/cli.rb
+- lib/coverage_reporter/coverage_analyzer.rb
+- lib/coverage_reporter/coverage_report_loader.rb
+- lib/coverage_reporter/global_comment.rb
+- lib/coverage_reporter/global_comment_poster.rb
+- lib/coverage_reporter/inline_comment.rb
+- lib/coverage_reporter/inline_comment_factory.rb
+- lib/coverage_reporter/inline_comment_poster.rb
+- lib/coverage_reporter/modified_ranges_extractor.rb
+- lib/coverage_reporter/options.rb
+- lib/coverage_reporter/pull_request.rb
+- lib/coverage_reporter/runner.rb
+- lib/coverage_reporter/simple_cov/patches/result_hash_formatter_patch.rb
+- lib/coverage_reporter/uncovered_ranges_extractor.rb
+- lib/coverage_reporter/version.rb
+- lib/tasks/coverage.rake
 homepage: https://github.com/gabrieltaylor/coverage-reporter
 licenses:
 - MIT

data/lib/coverage/reporter/version.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Coverage
-  module Reporter
-    VERSION = "0.1.0"
-  end
-end

data/lib/coverage/reporter.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Coverage
-  module Reporter
-    autoload :VERSION, "coverage/reporter/version"
-  end
-end