uncov 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71c9c6024e7115e88987532fd3fdb4e3667dd1d60701f558bc1c34a23e38c171
-  data.tar.gz: 9b89570ceac5692a3521e72e4faa35446c555c6c494b318d502e1c1c3fff98c5
+  metadata.gz: 397cffc8dced395da502cb60cc2136da4cb7f886ab0dc53636d8d3dd886b263b
+  data.tar.gz: 9d73dc0cbf0467f131d470f4ee486013daf64f2e73980749ffcad09ccb8fced7
 SHA512:
-  metadata.gz: 474941a337634f028565480b36b362a561cdb7b8c9a7105e998fadb89d23bf6717d070252dae19c991acb09b19d44357797b7964c20dfb0f78316a1f2d0c1ce5
-  data.tar.gz: e3cfbd78c00926fdc14c84c3e35d46d8141595eef8f07fa442172db7215c55502eda0e3ccf6e371cde39ccbc9c9e2e769ec8c0739924d2d7bfe9a0ad2a32a42d
+  metadata.gz: 5407ea15f650d927ec5887b5d1d0530caea5cefa92d3f9bbde1e0895de820cae5cf415d61a223af834d2265d717ac1ba4984b8e18ed547915ad55e1b86d04406
+  data.tar.gz: 21c9b8dc0af1213f24167b0a0442550444cb58fb3af667d8612951818a3301cd33c981d6151a3c69579a726a30057b62102c2f3fc207ffa56da3078495172d3f

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 2025-05-05: [v0.4.0](https://github.com/mpapis/uncov/releases/tag/v0.4.0)
+
+### Minor
+
+- [#38](https://github.com/mpapis/uncov/pull/38): Read configuration from file, by [@mpapis](https://github.com/mpapis)
+- [#39](https://github.com/mpapis/uncov/pull/39): Add output context lines, by [@mpapis](https://github.com/mpapis)
+
+### Patch
+
+- [#37](https://github.com/mpapis/uncov/pull/37): Fix exception raising without namespace, by [@mpapis](https://github.com/mpapis)
+
+
+
 ## 2025-04-30: [v0.3.0](https://github.com/mpapis/uncov/releases/tag/v0.3.0)
 
 ### Minor

data/CONTRIBUTING.md

@@ -1,26 +1,25 @@
 # Contributing
-Bug reports and pull requests are welcome on GitHub at https://github.com/mpapis/uncov.
 
-Do not know where to start? Help triaging issues, make sure they can be reproduced.
+## Want to help?
+- Bug reports and pull requests are welcome on GitHub at https://github.com/mpapis/uncov.
+- Do not know where to start? Help triaging issues, make sure they can be reproduced.
 
 
 ## 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.
 
+
 ## Development
 - `docker-compose build uncov` to (re-)build dev container,
 - `docker-compose run uncov` to enter dev container,
-- `bundle` to install dependencies,
-- `rake` to run test and lint,
-- `rake install` to install the gem,
-- `uncov` to see uncovered changes (check itself)
+- `bundle` to install dependencies and uncov,
+- `rake` to run lint, test and uncov - **precheck** before opening PR,
+- `uncov` to test manually
 
 
 ## Pull requests
-
-Open pull requests against the `develop` branch
+Open pull requests against the `develop` or `release-v*` branches.
 
 Branch prefix influences auto labeling next release:
 - `ignore/` - will not trigger next release (excluded from changelog),
@@ -28,13 +27,21 @@ Branch prefix influences auto labeling next release:
 - `feature/` - will bump minor version,
 - `breaking/` - will bump major version.
 
-If unsure it's not important, the release label's can be changed by maintainers.
+If unsure it's not important, the release label's (`release:*`) can be changed by maintainers.
 
 
 ## Release Process
+This gem uses GitHub Actions for continuous integration and automated releases.
 
-This gem uses GitHub Actions for continuous integration and automated releases. Here's how the release process works:
 
+### Check future changelog
+1. Go to the "Actions" tab in the GitHub repository
+2. Select the "Changelog" workflow
+3. Click "Run workflow"
+4. Go to "Summary" and see generated version and changelog
+
+
+### Release
 1. Go to the "Actions" tab in the GitHub repository
 2. Select the "Release" workflow
 3. Click "Run workflow"
@@ -46,9 +53,6 @@ This will:
 
 
 ## 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

data/PHILOSOPHY.md

@@ -0,0 +1,55 @@
+# What is uncov?
+`uncov` stands for uncovered code.
+
+
+## Why uncov
+I was irritated by manually checking which files were changed in git
+and then looking at each file coverage report for missing coverage.
+
+
+## Why code coverage
+This was tiresome but something that I thought was required to validate
+if I thought about important behaviors of my code in tests.
+
+
+## Code coverage is worthless
+Code coverage does not indicate quality of the tests,
+but lack of coverage indicates lack of testing specific behavior at all.
+
+Despite its limitations as a quality metric, we can use coverage insights
+as a starting point to develop better testing practices. Here's how:
+
+## How to improve quality of tests
+Think about testing behaviors, do not test implementation.
+This implies more work preparing test data / the state of the system,
+in a way that shows how the system behaves in specific conditions.
+
+There has been a lot written about how to test, learn how others approach testing/coverage:
+- https://testdesiderata.com/
+- https://martinfowler.com/bliki/TestCoverage.html
+- https://martinfowler.com/articles/practical-test-pyramid.html
+- https://www.betterspecs.org/
+- https://github.com/ch1ago/bdd
+
+There is a lot of gold in there, but I do not agree with everything there,
+you need to find your own way that works for your specific project needs.
+
+
+## How uncov helps
+`uncov` focuses your attention where it matters most - on recently changed code that lacks test coverage.
+By analyzing git diffs and connecting them to your test coverage results, `uncov`:
+- Identifies only the files you've modified, saving you time
+- Shows precisely which changed lines remain untested
+- Integrates with your existing test workflow through SimpleCov
+- Provides context around uncovered code to help you understand what needs testing
+
+This targeted approach helps you maintain high-quality tests for new and modified code
+without getting overwhelmed by legacy coverage issues.
+
+
+## Take action
+Ready to improve your testing workflow?
+
+Install uncov with `gem install uncov` and run it after making changes to immediately see which behaviors need tests.
+Check the [README](README.md) for more details and
+`uncov -h` for configuration options to customize uncov for your project's needs.

data/README.md

@@ -1,50 +1,86 @@
 # Uncov
+Uncov analyzes test coverage for changed files in your Git repository,
+helping you ensure that all your recent changes are properly tested.
 
-Uncov analyzes test coverage for changed files in your Git repository, helping you ensure that all your recent changes are properly tested.
+Uncov uses `git diff` to detect changes and `simplecov` reports to detect uncovered code.
 
-## Features
+[The uncov Manifesto](PHILOSOPHY.md)
+
+![report diff_lines to terminal output](diff_lines_terminal.png)
 
+## 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
+- Run tests automatically for (changed) relevant files
+- Print report of uncovered lines in (changed) files
 
-## Installation
 
+## Installation
 ```bash
 gem install uncov
 ```
-
 Or add to your Gemfile (only for convenience):
 ```ruby
 gem 'uncov', require: false
 ```
 
+
 ## Usage
 Basic usage:
 ```bash
 uncov
 ```
-With options:
+
+Display configuration options:
 ```bash
-uncov --target develop --path custom/coverage/path
+$ uncov -h
+Usage: uncov [options]
+    -t, --target TARGET              Target branch for comparison, default: "HEAD"
+    -r, --report TYPE                Report type to generate, one_of: "diff_lines"(default)
+    -o, --output-format FORMAT       Output format, one_of: "terminal"(default)
+    -C, --context LINES_NUMBER       Additional lines context in output, default: 1
+        --test-command COMMAND       Test command that generates SimpleCov, default: "COVERAGE=true bundle exec rake test"
+        --simplecov-file PATH        SimpleCov results file, default: "autodetect"
+        --relevant-files             Relevant files shell filename globing: https://ruby-doc.org/core-3.1.1/File.html#method-c-fnmatch, default: "{{bin,exe,exec}/*,{app,lib}/**/*.{rake,rb},Rakefile}"
+        --debug                      Get some insights, default: false
+    -v, --version                    Show version
+    -h, --help                       Print this help
+uncov 0.3.0 by Michal Papis <mpapis@gmail.com>
 ```
-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
 
+## Configuration file
+`.uncov` file in the directory where it's ran stores default options,
+specify one argument per line - this eliminates the need for special parsing of the file.
+
+Example:
+```text
+--target
+develop
+--test-command
+COVERAGE=1 rspec
+```
+
+
+## Using in CI
+`uncov` uses itself to check new missing code coverage [.github/workflows/ci.yml](.github/workflows/ci.yml),
+no need to set minimal, always get better.
+
+Ideas for CI:
+- run `uncov` after running your tests with coverage enabled,
+- be less restrictive - provide custom `--relevant-files` pattern
+  that excludes some paths you do not think should be always tested.
+
+
+## Requirements
 - Ruby 3.2+
 - A Git repository
 - SimpleCov for test coverage
 
+
 ## Contributing
 Contributing, developing, pull requests, releasing, security -> [CONTRIBUTING.md](CONTRIBUTING.md).
 
+
 ## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/uncov

@@ -3,4 +3,12 @@
 
 require 'uncov'
 
-Uncov::CLI.start(ARGV)
+status =
+  catch(:exit) do
+    case Uncov::CLI.start(ARGV)
+    when true then 0
+    when false then 1
+    else 128
+    end
+  end
+exit status

data/lib/uncov/cli.rb

@@ -5,49 +5,14 @@ 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.configure(args)
+    report = Uncov::Report.build
     Uncov::Formatter.output(report)
-    exit(report.covered? ? 0 : 1)
-  end
-
-  private
+    !report.uncov?
+  rescue StandardError => e
+    raise if Uncov.configuration.debug
 
-  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)
+    warn e.message
+    nil
   end
 end

data/lib/uncov/configuration/option.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# configuration option
+class Uncov::Configuration::Option
+  attr_reader :name, :description, :options, :default, :allowed_values, :value_parse, :value
+
+  def initialize(name, description, options, default, allowed_values, value_parse)
+    @name = name
+    @description = description
+    @options = Array(options)
+    @default = default.freeze
+    @allowed_values = allowed_values
+    @value_parse = value_parse
+    self.value = default
+  end
+
+  def value=(value)
+    if allowed_values&.none?(value)
+      raise \
+        Uncov::OptionValueNotAllowed,
+        "Configuration option(#{name.inspect}) tried to set: #{value.inspect}, only: #{allowed_values.inspect} allowed"
+    else
+      @value = value
+    end
+  end
+
+  def on_parser(parser) = parser.on(*options, options_description) { |value| self.value = value_parse.call(value) }
+
+  private
+
+  def options_description
+    if allowed_values
+      "#{description}, one_of: #{options_one_of.join(', ')}"
+    else
+      "#{description}, default: #{default.inspect}"
+    end
+  end
+
+  def options_one_of
+    allowed_values.map do |value|
+      if value == default
+        "#{value.inspect}(default)"
+      else
+        # :nocov: for now as there is no case yet in Configuration
+        value.inspect
+        # :nocov:
+      end
+    end
+  end
+end

data/lib/uncov/configuration.rb

@@ -1,17 +1,81 @@
 # frozen_string_literal: true
 
+require_relative 'formatter'
+require_relative 'report'
+
 # handle configuration for uncov
 class Uncov::Configuration
+  CONFIG_FILE = '.uncov'
   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
+
+  class << self
+    def option(name, description, options:, default:, allowed_values: nil, value_parse: ->(value) { value })
+      self.options << [name, description, options, default, allowed_values, value_parse]
+      define_method(name) { self.options[name].value }
+      define_method("#{name}=") { |value| self.options[name].value = value }
+    end
+
+    def options = @options ||= []
+  end
+
+  option 'target', 'Target branch for comparison', options: ['-t', '--target TARGET'], default: 'HEAD'
+  option 'report', 'Report type to generate', options: ['-r', '--report TYPE'], default: 'diff_lines', allowed_values: Uncov::Report.types
+  option 'output_format', 'Output format',
+         options: ['-o', '--output-format FORMAT'], default: 'terminal', allowed_values: Uncov::Formatter.formats
+  option 'context', 'Additional lines context in output',
+         options: ['-C', '--context LINES_NUMBER'], default: 1, value_parse: lambda(&:to_i)
+  option 'test_command', 'Test command that generates SimpleCov',
+         options: '--test-command COMMAND', default: 'COVERAGE=true bundle exec rake test'
+  option 'simplecov_file', 'SimpleCov results file', options: '--simplecov-file PATH', default: 'autodetect'
+  option 'relevant_files', 'Relevant files shell filename globing: https://ruby-doc.org/core-3.1.1/File.html#method-c-fnmatch',
+         options: '--relevant-files', default: '{{bin,exe,exec}/*,{app,lib}/**/*.{rake,rb},Rakefile}'
+  option 'debug', 'Get some insights', options: '--debug', default: false, value_parse: ->(_value) { true }
 
   def initialize
-    @git_diff_target = 'HEAD'
-    @test_command = 'COVERAGE=true bundle exec rake test'
-    @simplecov_output_path = 'autodetect'
-    @path = '.'
-    @relevant_files = ['{bin,exe,exec}/*', '{app,lib}/**/*.{rake,rb}']
-    @report = :diff_lines
-    @output_format = :terminal
+    define_options
+    parse_config
+  end
+
+  def parse_cli(args) = parser.parse!(args)
+  def options_values = options.to_h { |name, option| [name.to_sym, option.value] }
+
+  private
+
+  def define_options
+    self.class.options.each do |name, description, options, default, allowed_values, value_parse|
+      self.options[name] = Option.new(name, description, options, default, allowed_values, value_parse)
+    end
   end
+
+  def parse_config
+    return unless File.exist?(CONFIG_FILE)
+
+    args = File.readlines(CONFIG_FILE).map(&:strip)
+    parse_cli(args)
+  end
+
+  def parser
+    @parser ||=
+      OptionParser.new do |parser|
+        parser_header(parser)
+        options.each_value { |option| option.on_parser(parser) }
+        parser_footer(parser)
+      end
+  end
+
+  def parser_header(parser) = parser.banner = 'Usage: uncov [options]'
+
+  def parser_footer(parser)
+    parser.on('-v', '--version', 'Show version') do
+      puts "uncov #{Uncov::VERSION} by Michal Papis <mpapis@gmail.com>"
+      throw :exit, 0
+    end
+    parser.on('-h', '--help', 'Print this help') do
+      puts parser
+      puts "uncov #{Uncov::VERSION} by Michal Papis <mpapis@gmail.com>"
+      throw :exit, 0
+    end
+  end
+
+  def options = @options ||= {}
 end

data/lib/uncov/finder/file_system.rb

@@ -9,11 +9,7 @@ class Uncov::Finder::FileSystem
   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
+    Dir.glob(Uncov.configuration.relevant_files, Uncov::Configuration::FILE_MATCH_FLAGS).select { |f| File.file?(f) }
   end
 
   def lines_proc(file_name) = -> { cache(file_name) { read_lines(file_name) } }

data/lib/uncov/finder/git_base.rb

@@ -7,13 +7,11 @@ 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
+    File.fnmatch?(Uncov.configuration.relevant_files, path, Uncov::Configuration::FILE_MATCH_FLAGS)
   end
 
   def open_repo
-    ::Git.open(Uncov.configuration.path)
+    ::Git.open('.')
   rescue ArgumentError => e
     raise Uncov::NotGitRepoError, Uncov.configuration.path if e.message.end_with?(' is not in a git working tree')
 

data/lib/uncov/finder/git_diff.rb

@@ -19,24 +19,26 @@ module Uncov::Finder::GitDiff
     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] == '+'
+          next unless changed_line.content[0] == '+'
+
+          [changed_line.number, nil]
         end
       end.compact.to_h
     end
 
     def git_diff
       repo = open_repo
-      target =
-        case git_diff_target
+      git_target =
+        case target
         when 'HEAD'
-          git_diff_target
+          target
         else
-          repo.branches[git_diff_target] or raise NotGitBranchError, git_diff_target
+          repo.branches[target] or raise Uncov::NotGitBranchError, target
         end
 
-      repo.diff(target)
+      repo.diff(git_target)
     end
 
-    def git_diff_target = Uncov.configuration.git_diff_target
+    def target = Uncov.configuration.target
   end
 end

data/lib/uncov/finder/simple_cov.rb

@@ -5,7 +5,7 @@ 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 = [])
+    def files(trigger_files)
       regenerate_report if requires_regeneration?(trigger_files)
       raise_on_missing_coverage_path!
       coverage.transform_values { |file_coverage| covered_lines(file_coverage) }
@@ -14,6 +14,7 @@ module Uncov::Finder::SimpleCov
     private
 
     def requires_regeneration?(trigger_files)
+      return true unless coverage_path
       return true unless File.exist?(coverage_path)
       return false if trigger_files.empty?
 
@@ -21,10 +22,14 @@ module Uncov::Finder::SimpleCov
       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 regenerate_report
+      system(Uncov.configuration.test_command, exception: true)
+    rescue RuntimeError
+      raise Uncov::FailedToGenerateReport
+    end
 
     def coverage
-      root_path = "#{File.absolute_path(Uncov.configuration.path)}/"
+      root_path = "#{File.absolute_path('.')}/"
       parsed = JSON.parse(File.read(coverage_path))
       coverage = parsed['coverage'] || parsed.values.max_by { |suite| suite['timestamp'] }['coverage']
       coverage.transform_keys { |key| key.delete_prefix(root_path) }
@@ -32,24 +37,22 @@ module Uncov::Finder::SimpleCov
 
     def covered_lines(file_coverage)
       file_coverage['lines'].each_with_index.filter_map do |coverage, line_index|
-        [line_index + 1, coverage.positive?] if coverage
+        [line_index + 1, coverage.positive?] if coverage.is_a?(Integer)
       end.to_h
     end
 
     def coverage_path
-      if Uncov.configuration.simplecov_output_path == 'autodetect'
-        %w[coverage/coverage.json coverage/.resultset.json]
-          .map { |coverage_path| File.join(Uncov.configuration.path, coverage_path) }
-          .find { |path| File.exist?(path) }
+      if Uncov.configuration.simplecov_file == 'autodetect'
+        %w[coverage/coverage.json coverage/.resultset.json].find { |path| File.exist?(path) }
       else
-        File.join(Uncov.configuration.path, Uncov.configuration.simplecov_output_path)
+        Uncov.configuration.simplecov_file
       end
     end
 
     def raise_on_missing_coverage_path!
-      return if File.exist?(coverage_path)
+      return if coverage_path && File.exist?(coverage_path)
 
-      raise Uncov::AutodetectSimpleCovPathError if Uncov.configuration.simplecov_output_path == 'autodetect'
+      raise Uncov::AutodetectSimpleCovPathError if Uncov.configuration.simplecov_file == 'autodetect'
 
       raise Uncov::MissingSimpleCovReport, coverage_path
     end

data/lib/uncov/finder.rb

@@ -8,9 +8,10 @@ class Uncov::Finder
   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_line?(file_name, line_number) = git_diff_files[file_name].key?(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 file_system_file_lines(file_name) = file_system_files[file_name]&.call
   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)
 

data/lib/uncov/formatter/terminal.rb

@@ -5,6 +5,8 @@ require 'forwardable'
 
 # print report to terminal with colors
 class Uncov::Formatter::Terminal
+  include Uncov::Cache
+
   attr_reader :report
 
   def initialize(report)
@@ -12,29 +14,54 @@ class Uncov::Formatter::Terminal
   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
+    puts
+    puts format('Overall coverage of changes: %.2f%%', report.coverage).yellow
   end
 
-  def output_files = report.uncovered_files.each { |file_coverage| output_file(file_coverage) }
+  def output_files
+    report.uncovered_files.each do |file_coverage|
+      output_file(file_coverage)
+    end
+  end
 
   def output_file(file_coverage)
+    puts
+    output_file_header(file_coverage)
+    max = number_length(file_coverage)
+    file_coverage.display_lines.each do |line|
+      output_line(line, max)
+    end
+  end
+
+  def output_file_header(file_coverage)
     puts format(
-      "\n%<name>s -> %<coverage>.2f%% changes covered, uncovered lines:",
+      '%<name>s -> %<coverage>.2f%% (%<covered_lines>d / %<relevant_lines>d) changes covered, uncovered lines:',
       name: file_coverage.file_name,
-      coverage: file_coverage.coverage
+      coverage: file_coverage.coverage,
+      covered_lines: file_coverage.covered_lines.count,
+      relevant_lines: file_coverage.relevant_lines.count
     ).yellow
-    nl = number_length(file_coverage)
-    file_coverage.uncovered_lines.each do |line|
-      puts format("%#{nl}d: %s", line.number, line.content).red
+  end
+
+  def output_line(line, max)
+    if line.uncov?
+      puts format_line(line, max).red
+    elsif line.context
+      puts format_line(line, max).green
+    else
+      # :nocov:
+      raise 'unknown display line' # unreachable code
+      # :nocov:
     end
   end
 
-  def number_length(file_coverage) = file_coverage.uncovered_lines.last.number.to_s.length
+  def format_line(line, max)
+    format("%#{max}d: %s", line.number, line.content)
+  end
+
+  def number_length(file_coverage)
+    file_coverage.display_lines.last.number.to_s.length
+  end
 end

data/lib/uncov/formatter.rb

@@ -3,12 +3,26 @@
 # chose formater to output the report
 module Uncov::Formatter
   class << self
+    def formats = %w[terminal]
+
     def output(report)
+      if report.files.empty?
+        return puts 'No files to report.'.green
+      elsif !report.uncov?
+        return puts "All changed files(#{report.files.count}) have 100% test coverage!".green
+      end
+
+      output_report(report)
+    end
+
+    private
+
+    def output_report(report)
       case Uncov.configuration.output_format
-      when :terminal
+      when 'terminal'
         Uncov::Formatter::Terminal.new(report).output
       else
-        raise UnsupportedFormatterError, Uncov.configuration.output_format
+        raise Uncov::UnsupportedFormatterError, Uncov.configuration.output_format
       end
     end
   end

data/lib/uncov/report/context.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# calculate context for important lines,
+# @return [Integer] only added context lines matching all_line_numbers and not in important_line_numbers
+module Uncov::Report::Context
+  class << self
+    def calculate(all_line_numbers, important_line_number, context)
+      context_line_numbers = {}
+      important_line_number.each do |line_number|
+        (1..context).to_a.each do |offset|
+          context_line_numbers[line_number - offset] = true
+          context_line_numbers[line_number + offset] = true
+        end
+      end
+      (context_line_numbers.keys.sort & all_line_numbers) - important_line_number
+    end
+  end
+end

data/lib/uncov/report/diff_lines.rb

@@ -3,28 +3,59 @@
 # 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|
+    def files(finder)
+      finder.git_diff_file_names.map do |file_name|
         Uncov::Report::File.new(
           file_name:,
           git: true,
-          lines: lines(report, file_name)
+          lines: lines(finder, 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
-        )
+    def lines(finder, file_name)
+      lines_hash = git_diff_files_lines(finder, file_name)
+      add_context(finder, file_name, lines_hash)
+      lines_hash.sort.to_h.values
+    end
+
+    def git_diff_files_lines(finder, file_name)
+      finder.git_diff_file_lines(file_name).keys.to_h do |line_number|
+        [line_number, new_line(finder, file_name, line_number)]
+      end
+    end
+
+    def add_context(finder, file_name, lines_hash)
+      line_numbers =
+        lines_hash.filter_map do |line_number, line|
+          line_number if line.uncov?
+        end
+      all_line_numbers = finder.file_system_file_lines(file_name).keys
+      context_line_numbers = Uncov::Report::Context.calculate(all_line_numbers, line_numbers, Uncov.configuration.context)
+      context_line_numbers.each do |line_number|
+        context_line(finder, file_name, lines_hash, line_number)
       end
     end
+
+    def context_line(finder, file_name, lines_hash, line_number)
+      if lines_hash.key?(line_number)
+        lines_hash[line_number].context = true
+      else
+        lines_hash[line_number] = new_line(finder, file_name, line_number, context: true)
+      end
+    end
+
+    def new_line(finder, file_name, line_number, context: false)
+      Uncov::Report::File::Line.new(
+        number: line_number,
+        content: finder.file_system_file_line(file_name, line_number),
+        no_cov: finder.no_cov_file_line?(file_name, line_number),
+        simple_cov: finder.simple_cov_file_line?(file_name, line_number),
+        git_diff: finder.git_diff_file_line?(file_name, line_number),
+        context:
+      )
+    end
   end
 end

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

@@ -1,9 +1,16 @@
 # 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
+class Uncov::Report::File::Line < Uncov::Struct.new(:number, :content, :simple_cov, :no_cov, :context, :git_diff)
+  def uncov?
+    simple_cov == false && !no_cov
+  end
+
+  def display?
+    uncov? || context
+  end
+
+  def relevant?
+    !no_cov
   end
 end

data/lib/uncov/report/file.rb

@@ -1,17 +1,9 @@
 # frozen_string_literal: true
 
 # represents file coverage in report
-class Uncov::Report::File
+class Uncov::Report::File < Uncov::Struct.new(:file_name, :lines, :git)
   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?
@@ -22,9 +14,31 @@ class Uncov::Report::File
     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?)
+  def uncov?
+    uncov_lines.any?
+  end
+
+  def uncov_lines
+    cache(:uncov_lines) do
+      lines.select(&:uncov?)
+    end
+  end
+
+  def covered_lines
+    cache(:covered_lines) do
+      lines.reject(&:uncov?)
+    end
+  end
+
+  def display_lines
+    cache(:display_lines) do
+      lines.select(&:display?)
+    end
+  end
+
+  def relevant_lines
+    cache(:relevant_lines) do
+      lines.select(&:relevant?)
+    end
+  end
 end

data/lib/uncov/report.rb

@@ -1,22 +1,45 @@
 # frozen_string_literal: true
 
 require_relative 'cache'
+require_relative 'struct'
 
 # calculated coverage report for configured report type
-class Uncov::Report
+class Uncov::Report < Uncov::Struct.new(:files)
   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)
+  class << self
+    def types
+      %w[diff_lines]
+    end
+
+    def build
+      files =
+        case Uncov.configuration.report
+        when 'diff_lines'
+          finder = Uncov::Finder.new(:git_diff)
+          Uncov::Report::DiffLines.files(finder)
+        end
+      new(files:)
+    end
+  end
+
+  def uncovered_files
+    cache(:uncovered_files) do
+      files.select(&:uncov?)
+    end
+  end
+
+  def coverage
+    cache(:coverage) do
+      if files.empty?
+        100.0
+      else
+        files.sum(&:coverage) / files.size
       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?)
+  def uncov?
+    uncovered_files.any?
+  end
 end

data/lib/uncov/struct.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+class Uncov::Struct < Struct; end

data/lib/uncov/version.rb

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

data/lib/uncov.rb

@@ -7,22 +7,31 @@ Dir["#{File.dirname(__FILE__)}/**/*.rb"]
 # uncover missing code coverage by tests
 module Uncov
   class << self
-    attr_accessor :configuration
-
-    def configure
-      self.configuration ||= Configuration.new
+    def configure(args = [])
       yield(configuration) if block_given?
+      configuration.parse_cli(args) if args.any?
+      warn({ configuration: configuration.options_values }.inspect) if configuration.debug
+      nil
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
     end
 
-    def reset
-      self.configuration = Configuration.new
+    def configuration_reset!
+      @configuration = Configuration.new
     end
   end
 
-  class Error < StandardError; end
+  class Error < StandardError
+    def inspect = "#<#{self.class}: #{message}>"
+  end
+
+  class ConfigurationError < Error; end
   class GitError < Error; end
   class SimpleCovError < Error; end
   class FormatterError < Error; end
+  class OptionValueNotAllowed < ConfigurationError; end
 
   class NotGitRepoError < GitError
     attr_reader :path
@@ -38,6 +47,10 @@ module Uncov
     def message = "Target branch #{target_branch.inspect} not found locally or in remote"
   end
 
+  class FailedToGenerateReport < SimpleCovError
+    def message = cause.message
+  end
+
   class MissingSimpleCovReport < SimpleCovError
     attr_reader :coverage_path
 
@@ -46,7 +59,7 @@ module Uncov
   end
 
   class AutodetectSimpleCovPathError < SimpleCovError
-    def initialize = @message = 'Could not autodetect coverage report path'
+    def message = 'Could not autodetect coverage report path'
   end
 
   class UnsupportedFormatterError < FormatterError
@@ -56,6 +69,3 @@ module Uncov
     def message = "#{output_format.inspect} is not a supported formatter"
   end
 end
-
-# Initialize with defaults
-Uncov.configure

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uncov
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Michał Papis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-30 00:00:00.000000000 Z
+date: 2025-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: optparse
+  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'
 description: uncov compares your current branch with a target branch, identifies changed
   files, and reports on test coverage for those changes
 email:
@@ -76,15 +90,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- CHANGELOG_BLA.md
 - CONTRIBUTING.md
 - LICENSE.txt
+- PHILOSOPHY.md
 - README.md
 - bin/uncov
 - lib/uncov.rb
 - lib/uncov/cache.rb
 - lib/uncov/cli.rb
 - lib/uncov/configuration.rb
+- lib/uncov/configuration/option.rb
 - lib/uncov/finder.rb
 - lib/uncov/finder/file_system.rb
 - lib/uncov/finder/git.rb
@@ -95,9 +110,11 @@ files:
 - lib/uncov/formatter.rb
 - lib/uncov/formatter/terminal.rb
 - lib/uncov/report.rb
+- lib/uncov/report/context.rb
 - lib/uncov/report/diff_lines.rb
 - lib/uncov/report/file.rb
 - lib/uncov/report/file/line.rb
+- lib/uncov/struct.rb
 - lib/uncov/version.rb
 homepage: https://github.com/mpapis/uncov
 licenses:

data/CHANGELOG_BLA.md

@@ -1,28 +0,0 @@
-# Changelog
-
-## 2025-04-29: [v0.2.2](https://github.com/mpapis/uncov/releases/tag/v0.2.2)
-
-### Patch
-
-- [#27](https://github.com/mpapis/uncov/pull/27): Fix simplecov resultset parsing bug, by [@mpapis](https://github.com/mpapis)
-
-
-## 2025-04-29: [v0.2.1](https://github.com/mpapis/uncov/releases/tag/v0.2.1)
-
-### Patch
-
-- [#26](https://github.com/mpapis/uncov/pull/26): Fix simplecov resultset parsing bug, by [@mpapis](https://github.com/mpapis)
-
-
-## 2025-04-29: [v0.2.0](https://github.com/mpapis/uncov/releases/tag/v0.2.0)
-
-### Minor
-
-- [#23](https://github.com/mpapis/uncov/pull/23): Remove need for bundler, by [@mpapis](https://github.com/mpapis)
-
-
-## 2025-04-28: [v0.1.1](https://github.com/mpapis/uncov/releases/tag/v0.1.1)
-
-### Minor
-
-`uncov -r diff_lines -f termianl`, by [@mpapis](https://github.com/mpapis)