uncov 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2d0159da32804599de7afca67329f3d883857c049a2a681028d19cf940aec6be
+  data.tar.gz: 7aba6e5fddd2025ca51f9038770f41bce2b9b7426201d16c568e9a565b76fb78
+SHA512:
+  metadata.gz: 6e84d73647ed6996d0d3d85f05f87542e3f2820008332d842a3feb7d9b4d65b754bc986fcff2c0ae019bbb6e1e474de9cd09ffa82ba9591743af6f5c3e8a5e03
+  data.tar.gz: 2151c2f5d2c43ef2a8e1095867a8238f47030a4ab9b4b5a136b8fde9cb1c015e3e6de98410cf95b68784d9af9f3e369c5f6b9710a666b6280da75d4226157b60

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## [0.1.1] - 2025-04-28
+
+- releasing...
+
+
+## [0.1.0] - 2025-04-28
+
+- uncov -r diff_lines -f termianl

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright © 2025 
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# Uncov
+
+Uncov analyzes test coverage for changed files in your Git repository, helping you ensure that all your recent changes are properly tested.
+
+## Features
+
+- Compare your working tree to a target branch
+- Identify changed Ruby files
+- Check test coverage for those changes using SimpleCov
+- Run tests automatically for files without coverage data
+- Generate reports of uncovered lines in changed files
+
+## Installation
+
+```bash
+gem install uncov
+```
+
+Or add to your Gemfile:
+```ruby
+gem 'uncov'
+```
+
+## Usage
+Basic usage:
+```bash
+uncov
+```
+With options:
+```bash
+uncov --branch develop --path custom/coverage/path
+```
+Options
+- `-t`, `--target BRANCH`: Target branch for comparison (default: main)
+- `-c`, `--command COMMAND`: Test command to run (default: bundle exec rake test)
+- `-p`, `--path PATH`: Path to SimpleCov results (default: coverage/.resultset.json)
+- `-h`, `--help`: Display help
+- `-v`, `--version`: Display version
+
+## Requirements
+
+- Ruby 2.7+
+- A Git repository
+- SimpleCov for test coverage
+
+## Development
+- `docker-compose run uncov` to enter dev container,
+- `bundle` to install dependencies,
+- `bundle exec rake` to run test and lint,
+- `bin/uncov` to see uncovered changes (check itself)
+
+## Contributing
+Bug reports and pull requests are welcome on GitHub at https://github.com/mpapis/uncov.
+
+## Release Process
+This project uses an automated release process managed through GitHub Actions. For detailed information about contributing and the release workflow, please see [RELEASE.md](RELEASE.md).
+
+Maintainers can trigger new releases through the GitHub Actions interface with minimal manual intervention, following Semantic Versioning principles.
+
+## Security
+This project has security practices, please see [SECURITY.md](SECURITY.md).
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/RELEASE.md

@@ -0,0 +1,51 @@
+# Release Process
+
+This gem uses GitHub Actions for continuous integration and automated releases. Here's how the release process works:
+
+## For Contributors
+
+1. Develop features in feature branches
+2. Open pull requests against the `develop` branch
+3. Ensure CI passes and get code review approval
+4. Your changes will be included in the next release
+
+## For Maintainers
+
+### Preparing a Release
+
+1. Go to the "Actions" tab in the GitHub repository
+2. Select the "Prepare Release" workflow
+3. Click "Run workflow"
+4. Choose the version bump type (patch, minor, or major) following SemVer
+5. Optionally select "Create pre-release" for release candidates
+6. Click "Run workflow"
+
+This will:
+- Increment the version number appropriately
+- Generate a changelog based on PRs since the last release
+- Create a release branch and open a PR to main
+
+### Finalizing a Release
+
+1. Review and merge the auto-generated release PR into `main`
+2. The system will automatically:
+    - Create a git tag for the release
+    - Run tests one final time
+    - Build and publish the gem to RubyGems
+    - Create a GitHub Release with the changelog
+
+### Pre-releases
+
+For pre-releases (e.g. v1.2.0.pre1):
+1. Follow the normal preparation process but check "Create pre-release"
+2. The gem will be published to RubyGems as a pre-release version
+3. Users can install it with `gem install uncov --pre`
+
+## Manual Override
+
+If you need to create a release manually:
+1. Update version in `lib/uncov/version.rb`
+2. Update `CHANGELOG.md`
+3. Commit these changes to `main`
+4. Create and push a git tag: `git tag -a v1.2.3 -m "Release v1.2.3" && git push origin v1.2.3`
+5. The tag will trigger the release workflow

data/SECURITY.md

@@ -0,0 +1,21 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+If you discover a security vulnerability within uncov, please email [mpapis@gmail.com](mailto:mpapis@gmail.com).
+All security vulnerabilities will be promptly addressed.
+
+## Security Practices
+
+This project follows these security practices:
+
+1. **Code Review**:
+    - All pull requests must be reviewed by a project maintainer
+    - Workflow files cannot be modified without explicit review from core maintainers
+
+## Releasers
+
+Only the following GitHub accounts are authorized to release new versions:
+- @mpapis
+
+The rubygems release process uses [trusted publishing](https://guides.rubygems.org/trusted-publishing/).

data/bin/uncov

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+# :nocov:
+require 'uncov'
+# :nocov:
+
+Uncov::CLI.start(ARGV)

data/lib/uncov/cache.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# A caching helper for methods
+module Uncov::Cache
+  protected
+
+  def cache(key)
+    @cache ||= {}
+    return @cache[key] if @cache.key?(key)
+
+    @cache[key] = yield
+  end
+end

data/lib/uncov/cli.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+# provide terminal interface for uncov
+class Uncov::CLI
+  def self.start(args)
+    new.start(args)
+  end
+
+  def start(args)
+    parse_options(args)
+    report = Uncov::Report.new
+    Uncov::Formatter.output(report)
+    exit(report.covered? ? 0 : 1)
+  end
+
+  private
+
+  def parse_options(args) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    parser = OptionParser.new do |opts| # rubocop:disable Metrics/BlockLength
+      opts.banner = 'Usage: uncov [options]'
+      opts.on('-r', '--report TYPE', 'Report type to generate (git_diff)') do |type|
+        Uncov.configuration.report = type.to_sym
+      end
+      opts.on('-t', '--target BRANCH', 'Target branch for comparison') do |branch|
+        Uncov.configuration.git_diff_target = branch
+      end
+      opts.on('-c', '--command COMMAND', 'Test command to run SimpleCov') do |command|
+        Uncov.configuration.test_command = command
+      end
+      opts.on('-p', '--path PATH', 'Target filesystem path') do |path|
+        Uncov.configuration.path = path
+      end
+      opts.on('-f', '--formater FORMATTER', 'Formatter for output') do |formatter|
+        Uncov.configuration.output_format = formatter.to_sym
+      end
+      opts.on('--simplecov-path PATH', 'Path to SimpleCov results') do |path|
+        Uncov.configuration.simplecov_output_path = path
+      end
+      opts.on('-h', '--help', 'Print this help') do
+        puts opts
+        puts "uncov #{Uncov::VERSION} by Michal Papis <mpapis@gmail.com>"
+        exit
+      end
+      opts.on('-v', '--version', 'Show version') do
+        puts "uncov #{Uncov::VERSION} by Michal Papis <mpapis@gmail.com>"
+        exit
+      end
+    end
+    parser.parse!(args)
+  end
+end

data/lib/uncov/configuration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# handle configuration for uncov
+class Uncov::Configuration
+  FILE_MATCH_FLAGS = File::FNM_EXTGLOB | File::FNM_PATHNAME | File::FNM_DOTMATCH
+  attr_accessor :git_diff_target, :report, :output_format, :path, :relevant_files, :simplecov_output_path, :test_command
+
+  def initialize
+    @git_diff_target = 'HEAD'
+    @test_command = 'COVERAGE=true bundle exec rake test'
+    @simplecov_output_path = 'coverage/coverage.json'
+    @path = '.'
+    @relevant_files = ['{bin,exe,exec}/*', '{app,lib}/**/*.{rake,rb}']
+    @report = :diff_lines
+    @output_format = :terminal
+  end
+end

data/lib/uncov/finder/file_system.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# collect files and their lines content from system
+class Uncov::Finder::FileSystem
+  include Uncov::Cache
+
+  def files = all_files.to_h { |file_name| [file_name, lines_proc(file_name)] }
+
+  private
+
+  def all_files
+    Uncov.configuration.relevant_files.flat_map do |expresion|
+      Dir
+        .glob(expresion, Uncov::Configuration::FILE_MATCH_FLAGS, base: Uncov.configuration.path)
+        .select { |f| File.file?(f) }
+    end
+  end
+
+  def lines_proc(file_name) = -> { cache(file_name) { read_lines(file_name) } }
+
+  def read_lines(file_name)
+    File.readlines(file_name).each_with_index.to_h { |line, line_index| [line_index + 1, line.rstrip] }
+  end
+end

data/lib/uncov/finder/git.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'git_base'
+
+# collect list of files stored in git
+module Uncov::Finder::Git
+  class << self
+    include Uncov::Finder::GitBase
+
+    def files
+      open_repo.ls_files.keys.filter_map do |file_name|
+        [file_name, true] if relevant_file?(file_name)
+      end.to_h
+    end
+  end
+end

data/lib/uncov/finder/git_base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'git'
+
+# common parts for git finders
+module Uncov::Finder::GitBase
+  protected
+
+  def relevant_file?(path)
+    Uncov.configuration.relevant_files.any? do |pattern|
+      File.fnmatch?(pattern, path, Uncov::Configuration::FILE_MATCH_FLAGS)
+    end
+  end
+
+  def open_repo
+    ::Git.open(Uncov.configuration.path)
+  rescue ArgumentError => e
+    raise Uncov::NotGitRepoError, Uncov.configuration.path if e.message.end_with?(' is not in a git working tree')
+
+    raise
+  end
+end

data/lib/uncov/finder/git_diff.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'git_base'
+require 'git_diff_parser'
+
+# collect list of changed files and their added lines (removed do not impact coverage)
+module Uncov::Finder::GitDiff
+  class << self
+    include Uncov::Finder::GitBase
+
+    def files
+      git_diff.filter_map do |file_diff|
+        [file_diff.path, changed_lines(file_diff)] if relevant_file?(file_diff.path)
+      end.to_h
+    end
+
+    private
+
+    def changed_lines(file_diff)
+      GitDiffParser.parse(file_diff.patch).flat_map do |patch|
+        patch.changed_lines.map do |changed_line|
+          [changed_line.number, nil] if changed_line.content[0] == '+'
+        end
+      end.compact.to_h
+    end
+
+    def git_diff
+      repo = open_repo
+      target =
+        case git_diff_target
+        when 'HEAD'
+          git_diff_target
+        else
+          repo.branches[git_diff_target] or raise NotGitBranchError, git_diff_target
+        end
+
+      repo.diff(target)
+    end
+
+    def git_diff_target = Uncov.configuration.git_diff_target
+  end
+end

data/lib/uncov/finder/no_cov.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# collect nocov information from files
+class Uncov::Finder::NoCov
+  include Uncov::Cache
+
+  def files(all_files)
+    all_files.to_h { |file_name, lines| [file_name, nocov_proc(file_name, lines)] }
+  end
+
+  private
+
+  def nocov_proc(file_name, lines_proc) = -> { cache(file_name) { read_nocov(lines_proc) } }
+
+  def read_nocov(lines_proc)
+    nocov = false
+    lines_proc.call.filter_map do |number, line|
+      line_nocov = line.strip.start_with?('# :nocov:')
+      nocov = !nocov if line_nocov
+      [number, true] if nocov || line_nocov # still true on disabling line
+    end.to_h
+  end
+end

data/lib/uncov/finder/simple_cov.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'json'
+
+# collect coverage information, regenerates report if any trigger_files are newer then the report
+module Uncov::Finder::SimpleCov
+  class << self
+    def files(trigger_files = [])
+      regenerate_report if requires_regeneration?(trigger_files)
+      raise MissingSimpleCovReport, coverage_path unless File.exist?(coverage_path)
+
+      coverage.transform_values { |file_coverage| covered_lines(file_coverage) }
+    end
+
+    private
+
+    def requires_regeneration?(trigger_files)
+      return true unless File.exist?(coverage_path)
+      return false if trigger_files.empty?
+
+      coverage_path_mtime = File.mtime(coverage_path)
+      trigger_files.any? { |file_name| File.exist?(file_name) && File.mtime(file_name) > coverage_path_mtime }
+    end
+
+    def regenerate_report = Dir.chdir(Uncov.configuration.path) { system(Uncov.configuration.test_command) }
+
+    def coverage
+      root_path = "#{File.absolute_path(Uncov.configuration.path)}/"
+      parsed = JSON.parse(File.read(coverage_path))
+      coverage = parsed['coverage'] || parsed.order_by { |suite| suite['timestamp'] }.last['coverage']
+      coverage.transform_keys { |key| key.delete_prefix(root_path) }
+    end
+
+    def covered_lines(file_coverage)
+      file_coverage['lines'].each_with_index.filter_map do |coverage, line_index|
+        [line_index + 1, coverage.positive?] if coverage
+      end.to_h
+    end
+
+    def coverage_path = File.join(Uncov.configuration.path, Uncov.configuration.simplecov_output_path)
+  end
+end

data/lib/uncov/finder.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# collects information about the files from different sources
+class Uncov::Finder
+  include Uncov::Cache
+
+  def initialize(simple_cov_trigger) = @simple_cov_trigger = simple_cov_trigger
+  def git_file?(file_name) = git_files[file_name]
+  def git_file_names = git_files.keys
+  def git_diff_file_names = git_diff_files.keys
+  def git_diff_file_line?(file_name, line_number) = git_diff_files.dig(file_name, line_number)
+  def git_diff_file_lines(file_name) = git_diff_files[file_name]
+  def file_system_file_line(file_name, line_number) = file_system_files[file_name]&.call&.dig(line_number)
+  def no_cov_file_line?(file_name, line_number) = no_cov_files[file_name]&.call&.dig(line_number)
+  def simple_cov_file_line?(file_name, line_number) = simple_cov_files.dig(file_name, line_number)
+
+  def debug
+    {
+      git_files:,
+      git_diff_files:,
+      file_system_files: file_system_files.transform_values(&:call),
+      no_cov_files: no_cov_files.transform_values(&:call),
+      simple_cov_files:
+    }
+  end
+
+  private
+
+  attr_reader :simple_cov_trigger
+
+  def git_files = cache(:git_files) { Uncov::Finder::Git.files }
+  def git_diff_files = cache(:git_diff_files) { Uncov::Finder::GitDiff.files }
+  def file_system_files = cache(:file_system_files) { Uncov::Finder::FileSystem.new.files }
+  def no_cov_files = cache(:no_cov_files) { Uncov::Finder::NoCov.new.files(file_system_files) }
+  def simple_cov_files = cache(:simple_cov_files) { Uncov::Finder::SimpleCov.files(simple_cov_trigger_files) }
+
+  def simple_cov_trigger_files
+    case simple_cov_trigger
+    when :git
+      git_file_names
+    when :git_diff
+      git_diff_file_names
+    end
+  end
+end

data/lib/uncov/formatter/terminal.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'colorize'
+require 'forwardable'
+
+# print report to terminal with colors
+class Uncov::Formatter::Terminal
+  attr_reader :report
+
+  def initialize(report)
+    @report = report
+  end
+
+  def output
+    if report.covered?
+      puts 'All changed files have 100% test coverage!'.green
+      return
+    end
+
+    puts "Found #{report.uncovered_files.size} files with uncovered changes:".yellow
+    output_files
+    puts format("\nOverall coverage of changes: %.2f%%", report.coverage).yellow
+  end
+
+  def output_files = report.uncovered_files.each { |file_coverage| output_file(file_coverage) }
+
+  def output_file(file_coverage)
+    puts format(
+      "\n%<name>s -> %<coverage>.2f%% changes covered, uncovered lines:",
+      name: file_coverage.file_name,
+      coverage: file_coverage.coverage
+    ).yellow
+    nl = number_length(file_coverage)
+    file_coverage.uncovered_lines.each do |line|
+      puts format("%#{nl}d: %s", line.number, line.content).red
+    end
+  end
+
+  def number_length(file_coverage) = file_coverage.uncovered_lines.last.number.to_s.length
+end

data/lib/uncov/formatter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# chose formater to output the report
+module Uncov::Formatter
+  class << self
+    def output(report)
+      case Uncov.configuration.output_format
+      when :terminal
+        Uncov::Formatter::Terminal.new(report).output
+      else
+        raise UnsupportedFormatterError, Uncov.configuration.output_format
+      end
+    end
+  end
+end

data/lib/uncov/report/diff_lines.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# report only files lines from the diff
+module Uncov::Report::DiffLines
+  class << self
+    def files(report)
+      report.git_diff_file_names.map do |file_name|
+        Uncov::Report::File.new(
+          file_name:,
+          git: true,
+          lines: lines(report, file_name)
+        )
+      end
+    end
+
+    private
+
+    def lines(report, file_name)
+      report.git_diff_file_lines(file_name).keys.map do |line_number|
+        Uncov::Report::File::Line.new(
+          number: line_number,
+          content: report.file_system_file_line(file_name, line_number),
+          no_cov: report.no_cov_file_line?(file_name, line_number),
+          simple_cov: report.simple_cov_file_line?(file_name, line_number),
+          git_diff: true
+        )
+      end
+    end
+  end
+end

data/lib/uncov/report/file/line.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# represents file line coverage in report
+class Uncov::Report::File
+  Line = Struct.new('Line', :number, :content, :simple_cov, :no_cov, :git_diff) do
+    def covered? = simple_cov != false || no_cov
+    def relevant? = !no_cov
+  end
+end

data/lib/uncov/report/file.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# represents file coverage in report
+class Uncov::Report::File
+  include Uncov::Cache
+
+  attr_reader :file_name, :lines, :git
+
+  def initialize(file_name:, lines:, git:)
+    @file_name = file_name
+    @lines = lines
+    @git = git
+  end
+
+  def coverage
+    cache(:coverage) do
+      if relevant_lines.count.zero?
+        100.0
+      else
+        (covered_lines.count.to_f / relevant_lines.count * 100).round(2)
+      end
+    end
+  end
+
+  def covered? = lines.all?(&:covered?)
+  def changed_lines = lines.select(&:git_diff)
+  def covered_lines = lines.select(&:covered?)
+  def uncovered_lines = lines.reject(&:covered?)
+  def relevant_lines = lines.select(&:relevant?)
+end

data/lib/uncov/report.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'cache'
+
+# calculated coverage report for configured report type
+class Uncov::Report
+  include Uncov::Cache
+
+  def files
+    cache(:files) do
+      case Uncov.configuration.report
+      when :diff_lines
+        finder = Uncov::Finder.new(:git_diff)
+        Uncov::Report::DiffLines.files(finder)
+      end
+    end
+  end
+
+  def uncovered_files = cache(:uncovered_files) { files.reject(&:covered?) }
+  def coverage = cache(:coverage) { files.sum(&:coverage) / files.size }
+  def covered? = files.all?(&:covered?)
+end

data/lib/uncov/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Uncov
+  VERSION = '0.1.1'
+end

data/lib/uncov.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+Dir["#{File.dirname(__FILE__)}/**/*.rb"]
+  .sort_by { |f| f.count('/') }
+  .each { |f| require f unless f.end_with?('lib/uncov.rb') }
+
+# uncover missing code coverage by tests
+module Uncov
+  class << self
+    attr_accessor :configuration
+
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+    end
+
+    def reset
+      self.configuration = Configuration.new
+    end
+  end
+
+  class Error < StandardError; end
+  class GitError < Error; end
+  class SimpleCovError < Error; end
+  class FormatterError < Error; end
+
+  class NotGitRepoError < GitError
+    attr_reader :path
+
+    def initialize(path) = @path = path
+    def message = "#{path.inspect} is not in a git working tree"
+  end
+
+  class NotGitBranchError < GitError
+    attr_reader :target_branch
+
+    def initialize(target_branch) = @target_branch = target_branch
+    def message = "Target branch #{target_branch.inspect} not found locally or in remote"
+  end
+
+  class MissingSimpleCovReport < SimpleCovError
+    attr_reader :coverage_path
+
+    def initialize(coverage_path) = @coverage_path = coverage_path
+    def message = "SimpleCov results not found at #{coverage_path.inspect}"
+  end
+
+  class UnsupportedFormatterError < FormatterError
+    attr_reader :output_format
+
+    def initialize(output_format) = @output_format = output_format
+    def message = "#{output_format.inspect} is not a supported formatter"
+  end
+end
+
+# Initialize with defaults
+Uncov.configure

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: uncov
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Michał Papis
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: git_diff_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: uncov compares your current branch with a target branch, identifies changed
+  files, and reports on test coverage for those changes
+email:
+- mpapis@gmail.com
+executables:
+- uncov
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- RELEASE.md
+- SECURITY.md
+- bin/uncov
+- lib/uncov.rb
+- lib/uncov/cache.rb
+- lib/uncov/cli.rb
+- lib/uncov/configuration.rb
+- lib/uncov/finder.rb
+- lib/uncov/finder/file_system.rb
+- lib/uncov/finder/git.rb
+- lib/uncov/finder/git_base.rb
+- lib/uncov/finder/git_diff.rb
+- lib/uncov/finder/no_cov.rb
+- lib/uncov/finder/simple_cov.rb
+- lib/uncov/formatter.rb
+- lib/uncov/formatter/terminal.rb
+- lib/uncov/report.rb
+- lib/uncov/report/diff_lines.rb
+- lib/uncov/report/file.rb
+- lib/uncov/report/file/line.rb
+- lib/uncov/version.rb
+homepage: https://github.com/mpapis/uncov
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/mpapis/uncov
+  source_code_uri: https://github.com/mpapis/uncov
+  changelog_uri: https://github.com/mpapis/uncov/blob/develop/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Analyze test coverage for changed files in your git repository
+test_files: []