coverage-reporter 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 502fcd527b9376d80aa547f7d416fc6159c610c3806aee89b1ee47bf65b0d586
-  data.tar.gz: 90d60ffe2f23649fa8efa86603761ad3985eb5d623c81b9e80b782320682d0cc
+  metadata.gz: 13b5ede2585f67e28da56541940a417c9a2266f334a836d8ba4aae949f35a7aa
+  data.tar.gz: a23afcc6d059da70d2b0857e9a06af23177b0058690d66695596f7b7e0f774df
 SHA512:
-  metadata.gz: 004ef1c9498a942deb8514942fc91764a49aa24c70ba3186efbceb1ed4554b935837f857735df18a6900fda0c7916fca245fd2d555002913ca17b8dd596a671e
-  data.tar.gz: cd2007eaaa1eb78cd342c8ff43538d2878ca3fe756432b212b0534e0338fc7be02800ef26243ecf06911f3e10efebba5c85e9567bcf9b74353310032432ee157
+  metadata.gz: 29ba80d86581dd7f99b7141cec2e3a9a1fd81ae41dcff5d82d9305556b2a63489121946a9279cb92e905b24b983352ceb690c50ef1946f82ba7a95a2201dd25e
+  data.tar.gz: 592e4e220fea3f616aa7ca89938638fa463bb3a7a1ab5a3dce42ce4c0c9923baf44cba5fb2e7bfda525d5e30e524903a42c17296b0c44a547b9e02e611925cd7

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 report
+   ```
+
+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,44 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module CoverageReporter
+  class CLI
+    def self.start(argv)
+      case argv.first
+      when nil
+        show_usage_and_exit
+      when "report"
+        # Report command
+        options = Options::Report.parse(argv[1..])
+        Runner.new(options).run
+      when "collate"
+        collate_options = Options::Collate.parse(argv[1..])
+        CoverageCollator.new(collate_options).call
+      else
+        show_unknown_command_error(argv.first)
+      end
+    end
+
+    private_class_method def self.show_usage_and_exit
+      puts "Usage: coverage-reporter <command> [options]"
+      print_commands_list
+      exit 1
+    end
+
+    private_class_method def self.show_unknown_command_error(command)
+      puts "Unknown command: #{command}"
+      print_commands_list
+      exit 1
+    end
+
+    private_class_method def self.print_commands_list
+      puts ""
+      puts "Commands:"
+      puts "  report   Generate coverage report and post comments"
+      puts "  collate  Collate multiple coverage files"
+      puts ""
+      puts "Use 'coverage-reporter <command> --help' for command-specific options"
+    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_collator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module CoverageReporter
+  class CoverageCollator
+    def initialize(options={})
+      @coverage_dir = options[:coverage_dir]
+    end
+
+    def call
+      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_dir}/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
+
+    private
+
+    attr_reader :coverage_dir
+  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