uncov 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60ed1a2dd6520f9df75c5cc77e4b8b7b59d7ea61c6ae16c2e1ecad8bf86ae17a
-  data.tar.gz: 73bc05c3c969b1c8f2e7853f79aa96c2e793958c06bb0b0b3f4f6d03588501ca
+  metadata.gz: 328d5a3a593abb320621afee6841e28c19be46fd4ea1092ae52d6ef513131469
+  data.tar.gz: ba6658737c8230c2f90dd045a568c478dbee86d782d57c5c75e9f0d9303eb796
 SHA512:
-  metadata.gz: 860d74da20e5c28b665829510cfc0e2e0aef47f1ba179a7e6d4fd0038740bdbe8b60b6ae471e15c1677d06a6fea62609ec543328034a5de58d55249d7dcee713
-  data.tar.gz: '0927a3a3c86100b376d92766ff6f7311797bb6345407948e418a4366a40231f38db1b9486934f1278f36b2977407fb5cf36935cac89a98f9841be991e504aa47'
+  metadata.gz: abba73e5527b9f48108ecd90757036af35f4dd4f9a8b2c2399e7e9c9c804a5d99195bcc0f6d9117583f5f07e9efa2e94db15ccd3b3f3829c09629dcc9bcac57e
+  data.tar.gz: fdb66c5ff19eb0c3bcacb136147a3d3493ed44400602c071137b91fdc1edacbef6ef6fe13663aa05ae24c9cd68ac773b95080466aed1e4026de6b52a3bcf0a2b

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 2025-05-12: [v0.5.0](https://github.com/mpapis/uncov/releases/tag/v0.5.0)
+
+### Minor
+
+- [#43](https://github.com/mpapis/uncov/pull/43): Trigger tests on test_file_changes. Add git_files report generator., by [@mpapis](https://github.com/mpapis)
+- [#45](https://github.com/mpapis/uncov/pull/45): Add diff_files report type, by [@mpapis](https://github.com/mpapis)
+- [#46](https://github.com/mpapis/uncov/pull/46): Add nocov report filter and flags, by [@mpapis](https://github.com/mpapis)
+
+### Patch
+
+- [#44](https://github.com/mpapis/uncov/pull/44): Allow any git revision specification for target, by [@mpapis](https://github.com/mpapis)
+
+
+
 ## 2025-05-10: [v0.4.2](https://github.com/mpapis/uncov/releases/tag/v0.4.2)
 
 ### Patch

data/README.md

@@ -36,16 +36,33 @@ uncov
 $ 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)
+    -r, --report FILTER              Report filter to generate file/line list, one_of: "diff_files", "diff_lines"(default), "git_files", "nocov_lines"
     -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}"
+        --relevant-files FN_GLOB     Only show uncov for matching code files AND trigger tests if matching code files are newer than the report, default: "{{bin,exe,exec}/*,{app,lib}/**/*.{rake,rb},Rakefile}"
+        --relevant-tests FN_GLOB     Trigger tests if matching test files are newer than the report, default: "{test,spec}/**/*_{test,spec}.rb"
+        --nocov-ignore               Ignore :nocov: markers - consider all lines, default: false
+        --nocov-covered              Report :nocov: lines that have coverage, default: false
         --debug                      Get some insights, default: false
-    -v, --version                    Show version
     -h, --help                       Print this help
-uncov 0.4.2 by Michal Papis <mpapis@gmail.com>
+
+Report FILTERs:
+diff_files  - Report missing coverage on added/changed files in the git diff
+diff_lines  - Report missing coverage on added lines in the git diff
+git_files   - Report missing coverage on files tracked with git
+nocov_lines - Report coverage on nocov lines, requires one or both: --nocov-ignore / --nocov-covered
+
+Report FILTERs take NOTICE:
+git*/diff*  - filters will not consider new files unless added to the git index with `git add`.
+nocov*      - filters/flags only work with coverage/.resultset.json SimpleCov files,
+              coverage.json does not provide the information needed.
+
+FN_GLOB: shell filename globing -> https://ruby-doc.org/core-3.1.1/File.html#method-c-fnmatch
+         in bash: `shopt -s extglob dotglob globstar` and test with `ls {app,lib}/**/*.rb`
+
+uncov 0.5.0 by Michal Papis <mpapis@gmail.com>
 ```
 
 

data/lib/uncov/cli.rb

@@ -6,9 +6,9 @@ require 'optparse'
 class Uncov::CLI
   def self.start(args)
     Uncov.configure(args)
-    report = Uncov::Report.build
+    report = Uncov::Report.generate
     Uncov::Formatter.output(report)
-    !report.uncov?
+    !report.trigger?
   rescue StandardError => e
     raise if Uncov.configuration.debug
 

data/lib/uncov/configuration/option.rb

@@ -2,16 +2,16 @@
 
 # configuration option
 class Uncov::Configuration::Option
-  attr_reader :name, :description, :options, :default, :allowed_values, :value_parse, :value
+  attr_reader :name, :description, :options, :default, :value_parse, :value
 
   def initialize(name, description, options, default, allowed_values, value_parse)
     @name = name
     @description = description
     @options = Array(options)
     @default = default.freeze
+    @value = default
     @allowed_values = allowed_values
     @value_parse = value_parse
-    self.value = default
   end
 
   def value=(value)
@@ -41,10 +41,16 @@ class Uncov::Configuration::Option
       if value == default
         "#{value.inspect}(default)"
       else
-        # :nocov: for now as there is no case yet in Configuration
         value.inspect
-        # :nocov:
       end
     end
   end
+
+  def allowed_values
+    if @allowed_values.respond_to?(:call)
+      @allowed_values = @allowed_values.call
+    else
+      @allowed_values
+    end
+  end
 end

data/lib/uncov/configuration.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require_relative 'formatter'
-require_relative 'report'
+require_relative 'report/generator'
 
 # handle configuration for uncov
 class Uncov::Configuration
   CONFIG_FILE = '.uncov'
+  # equivalent of `shopt -s extglob dotglob globstar` for testing with `bash` & `ls`
   FILE_MATCH_FLAGS = File::FNM_EXTGLOB | File::FNM_PATHNAME | File::FNM_DOTMATCH
 
   class << self
@@ -19,16 +20,23 @@ class Uncov::Configuration
   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 'report', 'Report filter to generate file/line list',
+         options: ['-r', '--report FILTER'], default: 'diff_lines', allowed_values: -> { Uncov::Report::Generator.filters.keys }
   option 'output_format', 'Output format',
-         options: ['-o', '--output-format FORMAT'], default: 'terminal', allowed_values: Uncov::Formatter.formats
+         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 'relevant_files', 'Only show uncov for matching code files AND trigger tests if matching code files are newer than the report',
+         options: '--relevant-files FN_GLOB', default: '{{bin,exe,exec}/*,{app,lib}/**/*.{rake,rb},Rakefile}'
+  option 'relevant_tests', 'Trigger tests if matching test files are newer than the report',
+         options: '--relevant-tests FN_GLOB', default: '{test,spec}/**/*_{test,spec}.rb'
+  option 'nocov_ignore', 'Ignore :nocov: markers - consider all lines',
+         options: '--nocov-ignore', default: false, value_parse: ->(_value) { true }
+  option 'nocov_covered', 'Report :nocov: lines that have coverage',
+         options: '--nocov-covered', default: false, value_parse: ->(_value) { true }
   option 'debug', 'Get some insights', options: '--debug', default: false, value_parse: ->(_value) { true }
 
   def initialize
@@ -66,16 +74,40 @@ class Uncov::Configuration
   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>"
+      puts parser.help
       throw :exit, 0
     end
+    footer_extras(parser)
   end
 
-  def options = @options ||= {}
+  def footer_extras(parser)
+    # TODO: the release workflow does not like ' in help, please avoid it - or fix the workflow
+    parser.separator <<~HELP
+
+      Report FILTERs:
+      #{footer_extras_types}
+
+      Report FILTERs take NOTICE:
+      git*/diff*  - filters will not consider new files unless added to the git index with `git add`.
+      nocov*      - filters/flags only work with coverage/.resultset.json SimpleCov files,
+                    coverage.json does not provide the information needed.
+
+      FN_GLOB: shell filename globing -> https://ruby-doc.org/core-3.1.1/File.html#method-c-fnmatch
+               in bash: `shopt -s extglob dotglob globstar` and test with `ls {app,lib}/**/*.rb`
+
+      uncov #{Uncov::VERSION} by Michal Papis <mpapis@gmail.com>
+    HELP
+  end
+
+  def footer_extras_types
+    report_type_length = Uncov::Report::Generator.filters.keys.map(&:length).max
+    Uncov::Report::Generator.filters.map do |name, config|
+      "#{name.ljust(report_type_length)} - #{config[:description]}"
+    end.join("\n")
+  end
+
+  def options
+    @options ||= {}
+  end
 end

data/lib/uncov/finder/file_system.rb

@@ -4,7 +4,11 @@
 class Uncov::Finder::FileSystem
   include Uncov::Cache
 
-  def files = all_files.to_h { |file_name| [file_name, lines_proc(file_name)] }
+  def files
+    all_files.to_h do |file_name|
+      [file_name, lines(file_name)]
+    end
+  end
 
   private
 
@@ -12,7 +16,11 @@ class Uncov::Finder::FileSystem
     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) } }
+  def lines(file_name)
+    cache(file_name) do
+      read_lines(file_name)
+    end
+  end
 
   def read_lines(file_name)
     File.readlines(file_name).each_with_index.to_h { |line, line_index| [line_index + 1, line.rstrip] }

data/lib/uncov/finder/git.rb

@@ -3,14 +3,30 @@
 require_relative 'git_base'
 
 # collect list of files stored in git
-module Uncov::Finder::Git
-  class << self
-    include Uncov::Finder::GitBase
+class Uncov::Finder::Git
+  include Uncov::Finder::GitBase
 
-    def files
-      open_repo.ls_files.keys.filter_map do |file_name|
-        [file_name, true] if relevant_file?(file_name)
+  def code_files
+    cache(:code_files) do
+      all_file_names.filter_map do |file_name|
+        [file_name, true] if relevant_code_file?(file_name)
       end.to_h
     end
   end
+
+  def test_files
+    cache(:test_files) do
+      all_file_names.filter_map do |file_name|
+        [file_name, true] if relevant_test_file?(file_name)
+      end.to_h
+    end
+  end
+
+  private
+
+  def all_file_names
+    cache(:all_files) do
+      open_repo.ls_files.keys
+    end
+  end
 end

data/lib/uncov/finder/git_base.rb

@@ -4,14 +4,22 @@ require 'git'
 
 # common parts for git finders
 module Uncov::Finder::GitBase
+  include Uncov::Cache
+
   protected
 
-  def relevant_file?(path)
+  def relevant_code_file?(path)
     File.fnmatch?(Uncov.configuration.relevant_files, path, Uncov::Configuration::FILE_MATCH_FLAGS)
   end
 
+  def relevant_test_file?(path)
+    File.fnmatch?(Uncov.configuration.relevant_tests, path, Uncov::Configuration::FILE_MATCH_FLAGS)
+  end
+
   def open_repo
-    ::Git.open('.')
+    cache(:repo) do
+      ::Git.open('.')
+    end
   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

@@ -4,41 +4,57 @@ 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
+class Uncov::Finder::GitDiff
+  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) && File.exist?(file_diff.path)
+  def code_files
+    cache(:code_files) do
+      all_files_diff.filter_map do |file_diff|
+        [file_diff.path, changed_lines(file_diff)] if relevant_code_file?(file_diff.path) && File.exist?(file_diff.path)
       end.to_h
     end
+  end
 
-    private
+  def test_files
+    cache(:test_files) do
+      all_files_diff.filter_map do |file_diff|
+        [file_diff.path, true] if relevant_test_file?(file_diff.path) && File.exist?(file_diff.path)
+      end.to_h
+    end
+  end
 
-    def changed_lines(file_diff)
-      GitDiffParser.parse(file_diff.patch).flat_map do |patch|
-        patch.changed_lines.map do |changed_line|
-          next unless changed_line.content[0] == '+'
+  private
 
-          [changed_line.number, nil]
-        end
-      end.compact.to_h
+  def all_files_diff
+    cache(:all_files) do
+      git_diff
     end
+  end
 
-    def git_diff
-      repo = open_repo
-      git_target =
-        case target
-        when 'HEAD'
-          target
-        else
-          repo.branches[target] or raise Uncov::NotGitBranchError, target
-        end
-
-      repo.diff(git_target)
-    end
+  def changed_lines(file_diff)
+    GitDiffParser.parse(file_diff.patch).flat_map do |patch|
+      patch.changed_lines.map do |changed_line|
+        next unless changed_line.content[0] == '+'
+
+        [changed_line.number, nil]
+      end
+    end.compact.to_h
+  end
+
+  def git_diff
+    repo = open_repo
+    # TODO: resolve the need for verifying the target with git gem
+    git_target = repo.lib.send(:command, 'rev-parse', '--verify', target)
+    repo.diff(git_target)
+  rescue Git::FailedError => e
+    raise Uncov::NotGitObjectError, target if e.result.status.exitstatus == 128 && e.result.stderr.include?('fatal: Needed a single revision')
+
+    # :nocov: when we find a failing example, we can test it
+    raise
+    # :nocov:
+  end
 
-    def target = Uncov.configuration.target
+  def target
+    Uncov.configuration.target
   end
 end

data/lib/uncov/finder/no_cov.rb

@@ -5,16 +5,22 @@ 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)] }
+    all_files.to_h do |file_name, lines|
+      [file_name, nocov_lines(file_name, lines)]
+    end
   end
 
   private
 
-  def nocov_proc(file_name, lines_proc) = -> { cache(file_name) { read_nocov(lines_proc) } }
+  def nocov_lines(file_name, lines)
+    cache(file_name) do
+      read_nocov(lines)
+    end
+  end
 
-  def read_nocov(lines_proc)
+  def read_nocov(lines)
     nocov = false
-    lines_proc.call.filter_map do |number, line|
+    lines.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

data/lib/uncov/finder/simple_cov.rb

@@ -8,18 +8,33 @@ module Uncov::Finder::SimpleCov
     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) }
+      coverage.transform_values do |file_coverage|
+        covered_lines(file_coverage)
+      end
     end
 
     private
 
     def requires_regeneration?(trigger_files)
+      if Uncov.configuration.debug
+        warn("{coverage_path: #{coverage_path}(#{coverage_path && File.exist?(coverage_path) ? 'exist' : 'missing'})}")
+        warn("{trigger_files: #{trigger_files.inspect}}")
+      end
       return true unless coverage_path
       return true unless File.exist?(coverage_path)
       return false if trigger_files.empty?
 
+      changed_files?(trigger_files)
+    end
+
+    def changed_files?(trigger_files)
       coverage_path_mtime = File.mtime(coverage_path)
-      trigger_files.any? { |file_name| File.exist?(file_name) && File.mtime(file_name) > coverage_path_mtime }
+      changed_trigger_files =
+        trigger_files.select do |file_name|
+          File.exist?(file_name) && File.mtime(file_name) > coverage_path_mtime
+        end
+      warn("{changed_trigger_files: #{changed_trigger_files.inspect}}") if Uncov.configuration.debug
+      changed_trigger_files.any?
     end
 
     def regenerate_report

data/lib/uncov/finder.rb

@@ -8,19 +8,24 @@ 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[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 git_diff_file_line?(file_name, line_number) = git_diff_files[file_name]&.key?(line_number)
+  def file_system_file_names = file_system_files.keys
+  def file_system_file_line(file_name, line_number) = file_system_files[file_name]&.dig(line_number)
+  def file_system_file_lines(file_name) = file_system_files[file_name]
+  def no_cov_file_names = no_cov_files.keys
+  def no_cov_file_lines(file_name) = no_cov_files[file_name]
+  def no_cov_file_line?(file_name, line_number) = no_cov_files[file_name]&.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_test_files:,
       git_diff_files:,
-      file_system_files: file_system_files.transform_values(&:call),
-      no_cov_files: no_cov_files.transform_values(&:call),
+      git_diff_test_files:,
+      file_system_files:,
+      no_cov_files:,
       simple_cov_files:
     }
   end
@@ -29,18 +34,64 @@ class Uncov::Finder
 
   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 git_files
+    git_finder.code_files
+  end
+
+  def git_test_files
+    git_finder.test_files
+  end
+
+  def git_finder
+    cache(:git_finder) do
+      Uncov::Finder::Git.new
+    end
+  end
+
+  def git_diff_files
+    git_diff_finder.code_files
+  end
+
+  def git_diff_test_files
+    git_diff_finder.test_files
+  end
+
+  def git_diff_finder
+    cache(:git_diff_finder) do
+      Uncov::Finder::GitDiff.new
+    end
+  end
+
+  def file_system_files
+    cache(:file_system_files) do
+      Uncov::Finder::FileSystem.new.files
+    end
+  end
+
+  def no_cov_files
+    cache(:no_cov_files) do
+      Uncov::Finder::NoCov.new.files(file_system_files)
+    end
+  end
+
+  def simple_cov_files
+    cache(:simple_cov_files) do
+      Uncov::Finder::SimpleCov.files(simple_cov_trigger_files)
+    end
+  end
 
   def simple_cov_trigger_files
     case simple_cov_trigger
     when :git
-      git_file_names
+      git_file_names + git_test_files.keys
     when :git_diff
-      git_diff_file_names
+      git_diff_file_names + git_diff_test_files.keys
+    when :file_system
+      file_system_file_names
+    else
+      # :nocov:
+      raise Uncov::UnsupportedSimpleCovTriggerError, simple_cov_trigger
+      # :nocov:
     end
   end
 end

data/lib/uncov/formatter/terminal.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'colorize'
-require 'forwardable'
 
 # print report to terminal with colors
 class Uncov::Formatter::Terminal
@@ -14,14 +13,19 @@ class Uncov::Formatter::Terminal
   end
 
   def output
-    puts "Found #{report.uncovered_files.size} files with uncovered changes:".yellow
+    puts "Found #{report.display_files.size} files with uncovered changes:".yellow
     output_files
     puts
-    puts format('Overall coverage of changes: %.2f%%', report.coverage).yellow
+    puts format(
+      'Overall coverage of changes: %<coverage>.2f%% (%<covered_lines>d / %<relevant_lines>d)',
+      coverage: report.coverage,
+      covered_lines: report.covered_lines_count,
+      relevant_lines: report.relevant_lines_count
+    ).yellow
   end
 
   def output_files
-    report.uncovered_files.each do |file_coverage|
+    report.display_files.each do |file_coverage|
       output_file(file_coverage)
     end
   end
@@ -40,8 +44,8 @@ class Uncov::Formatter::Terminal
       '%<name>s -> %<coverage>.2f%% (%<covered_lines>d / %<relevant_lines>d) changes covered, uncovered lines:',
       name: file_coverage.file_name,
       coverage: file_coverage.coverage,
-      covered_lines: file_coverage.covered_lines.count,
-      relevant_lines: file_coverage.relevant_lines.count
+      covered_lines: file_coverage.covered_lines_count,
+      relevant_lines: file_coverage.relevant_lines_count
     ).yellow
   end
 
@@ -50,6 +54,8 @@ class Uncov::Formatter::Terminal
       puts format_line(line, max).red
     elsif line.context
       puts format_line(line, max).green
+    elsif line.nocov_covered?
+      puts format_line(line, max).blue
     else
       # :nocov:
       raise 'unknown display line' # unreachable code

data/lib/uncov/formatter.rb

@@ -8,7 +8,7 @@ module Uncov::Formatter
     def output(report)
       if report.files.empty?
         return puts 'No files to report.'.green
-      elsif !report.uncov?
+      elsif !report.trigger?
         return puts "All changed files(#{report.files.count}) have 100% test coverage!".green
       end
 

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

@@ -2,19 +2,38 @@
 
 # represents file line coverage in report
 class Uncov::Report::File::Line < Uncov::Struct.new(:number, :content, :simple_cov, :no_cov, :context, :git_diff)
+  def no_cov
+    return false if Uncov.configuration.nocov_ignore
+
+    self[:no_cov]
+  end
+
   def uncov?
     simple_cov == false && !no_cov
   end
 
+  def nocov_covered?
+    # :nocov
+    Uncov.configuration.nocov_covered && simple_cov == true && self[:no_cov]
+    # :nocov
+  end
+
   def covered?
-    simple_cov == true && !no_cov
+    return false if Uncov.configuration.nocov_ignore && self[:no_cov]
+
+    (simple_cov == true && !no_cov) ||
+      (Uncov.configuration.nocov_covered && simple_cov == false && self[:no_cov])
+  end
+
+  def trigger?
+    uncov? || nocov_covered?
   end
 
   def display?
-    uncov? || context
+    trigger? || context
   end
 
   def relevant?
-    [false, true].include?(simple_cov) && !no_cov
+    trigger? || covered?
   end
 end

data/lib/uncov/report/file.rb

@@ -6,27 +6,27 @@ class Uncov::Report::File < Uncov::Struct.new(:file_name, :lines, :git)
 
   def coverage
     cache(:coverage) do
-      if relevant_lines.count.zero?
+      if relevant_lines_count.zero?
         100.0
       else
-        (covered_lines.count.to_f / relevant_lines.count * 100).round(2)
+        (covered_lines_count.to_f / relevant_lines_count * 100).round(2)
       end
     end
   end
 
-  def uncov?
-    uncov_lines.any?
+  def trigger?
+    cache(:trigger) do
+      lines.any?(&:trigger?)
+    end
   end
 
-  def uncov_lines
-    cache(:uncov_lines) do
-      lines.select(&:uncov?)
-    end
+  def display?
+    display_lines.any?
   end
 
-  def covered_lines
-    cache(:covered_lines) do
-      lines.select(&:covered?)
+  def covered_lines_count
+    cache(:covered_lines_count) do
+      lines.count(&:covered?)
     end
   end
 
@@ -36,9 +36,9 @@ class Uncov::Report::File < Uncov::Struct.new(:file_name, :lines, :git)
     end
   end
 
-  def relevant_lines
-    cache(:relevant_lines) do
-      lines.select(&:relevant?)
+  def relevant_lines_count
+    cache(:relevant_lines_count) do
+      lines.count(&:relevant?)
     end
   end
 end

data/lib/uncov/report/generator/diff_files.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# report only files lines from the diff
+module Uncov::Report::Generator::DiffFiles
+  Uncov::Report::Generator.register(self, :git_diff, 'Report missing coverage on added/changed files in the git diff')
+
+  class << self
+    def files(finder)
+      finder.git_diff_file_names.map do |file_name|
+        Uncov::Report::File.new(
+          file_name:,
+          git: true,
+          lines: lines(finder, file_name)
+        )
+      end
+    end
+
+    private
+
+    def lines(finder, file_name)
+      lines_hash = file_lines(finder, file_name)
+      add_context(lines_hash)
+      lines_hash.sort.to_h.values
+    end
+
+    def file_lines(finder, file_name)
+      finder.file_system_file_lines(file_name).to_h do |line_number, content|
+        [line_number, new_line(finder, file_name, line_number, content)]
+      end
+    end
+
+    def add_context(lines_hash)
+      return if Uncov.configuration.context.zero?
+
+      line_numbers =
+        lines_hash.filter_map do |line_number, line|
+          line_number if line.trigger?
+        end
+      all_line_numbers = lines_hash.keys
+      context_line_numbers = Uncov::Report::Context.calculate(all_line_numbers, line_numbers, Uncov.configuration.context)
+      context_line_numbers.each do |line_number|
+        lines_hash[line_number].context = true
+      end
+    end
+
+    def new_line(finder, file_name, line_number, content)
+      Uncov::Report::File::Line.new(
+        number: line_number,
+        content:,
+        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: false
+      )
+    end
+  end
+end

data/lib/uncov/report/{diff_lines.rb → generator/diff_lines.rb}

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 # report only files lines from the diff
-module Uncov::Report::DiffLines
+module Uncov::Report::Generator::DiffLines
+  Uncov::Report::Generator.register(self, :git_diff, 'Report missing coverage on added lines in the git diff')
+
   class << self
     def files(finder)
       finder.git_diff_file_names.map do |file_name|
@@ -32,7 +34,7 @@ module Uncov::Report::DiffLines
 
       line_numbers =
         lines_hash.filter_map do |line_number, line|
-          line_number if line.uncov?
+          line_number if line.trigger?
         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)

data/lib/uncov/report/generator/git_files.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# report only files lines from the diff
+module Uncov::Report::Generator::GitFiles
+  Uncov::Report::Generator.register(self, :git, 'Report missing coverage on files tracked with git')
+
+  class << self
+    def files(finder)
+      finder.git_file_names.map do |file_name|
+        Uncov::Report::File.new(
+          file_name:,
+          git: true,
+          lines: lines(finder, file_name)
+        )
+      end
+    end
+
+    private
+
+    def lines(finder, file_name)
+      lines_hash = file_lines(finder, file_name)
+      add_context(lines_hash)
+      lines_hash.sort.to_h.values
+    end
+
+    def file_lines(finder, file_name)
+      finder.file_system_file_lines(file_name).to_h do |line_number, content|
+        [line_number, new_line(finder, file_name, line_number, content)]
+      end
+    end
+
+    def add_context(lines_hash)
+      return if Uncov.configuration.context.zero?
+
+      line_numbers =
+        lines_hash.filter_map do |line_number, line|
+          line_number if line.trigger?
+        end
+      all_line_numbers = lines_hash.keys
+      context_line_numbers = Uncov::Report::Context.calculate(all_line_numbers, line_numbers, Uncov.configuration.context)
+      context_line_numbers.each do |line_number|
+        lines_hash[line_number].context = true
+      end
+    end
+
+    def new_line(finder, file_name, line_number, content)
+      Uncov::Report::File::Line.new(
+        number: line_number,
+        content:,
+        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: false
+      )
+    end
+  end
+end

data/lib/uncov/report/generator/nocov_lines.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# report only files lines from the diff
+module Uncov::Report::Generator::NocovLines
+  Uncov::Report::Generator.register(self, :file_system, 'Report coverage on nocov lines, requires one or both: --nocov-ignore / --nocov-covered')
+
+  class << self
+    def files(finder)
+      finder.no_cov_file_names.filter_map do |file_name|
+        next if finder.no_cov_file_lines(file_name).empty?
+
+        Uncov::Report::File.new(
+          file_name:,
+          git: finder.git_file?(file_name),
+          lines: lines(finder, file_name)
+        )
+      end
+    end
+
+    private
+
+    def lines(finder, file_name)
+      lines_hash = nocov_files_lines(finder, file_name)
+      add_context(finder, file_name, lines_hash)
+      lines_hash.sort.to_h.values
+    end
+
+    def nocov_files_lines(finder, file_name)
+      finder.no_cov_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)
+      return if Uncov.configuration.context.zero?
+
+      line_numbers =
+        lines_hash.filter_map do |line_number, line|
+          line_number if line.trigger?
+        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/generator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../report'
+
+# generate report files and lines for the configured report type
+module Uncov::Report::Generator
+  class << self
+    def filters
+      @filters ||= {}
+    end
+
+    def register(generator_class, simple_cov_trigger, description)
+      class_name = generator_class.to_s.split('::').last
+      generator_name = class_name.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+      filters[generator_name] = { generator_class:, simple_cov_trigger:, description: }
+    end
+
+    def generate
+      raise Uncov::UnsupportedReportTypeError, Uncov.configuration.report unless filters.key?(Uncov.configuration.report)
+
+      filters[Uncov.configuration.report] => { generator_class:, simple_cov_trigger: }
+      generator_class.files(Uncov::Finder.new(simple_cov_trigger))
+    end
+  end
+end

data/lib/uncov/report.rb

@@ -8,38 +8,37 @@ class Uncov::Report < Uncov::Struct.new(:files)
   include Uncov::Cache
 
   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:)
+    def generate
+      new(files: Uncov::Report::Generator.generate)
     end
   end
 
-  def uncovered_files
-    cache(:uncovered_files) do
-      files.select(&:uncov?)
+  def display_files
+    cache(:display_files) do
+      files.select(&:display?)
     end
   end
 
   def coverage
     cache(:coverage) do
-      if files.empty?
+      if relevant_lines_count.zero?
         100.0
       else
-        (files.sum(&:coverage) / files.size).round(2)
+        (covered_lines_count.to_f / relevant_lines_count * 100).round(2)
       end
     end
   end
 
-  def uncov?
-    uncovered_files.any?
+  def relevant_lines_count = files.sum(&:relevant_lines_count)
+  def covered_lines_count = files.sum(&:covered_lines_count)
+
+  def trigger?
+    cache(:trigger) do
+      files.any?(&:trigger?)
+    end
+  end
+
+  def display?
+    display_files.any?
   end
 end

data/lib/uncov/version.rb

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

data/lib/uncov.rb

@@ -10,7 +10,7 @@ module Uncov
     def configure(args = [])
       yield(configuration) if block_given?
       configuration.parse_cli(args) if args.any?
-      warn({ configuration: configuration.options_values }.inspect) if configuration.debug
+      warn("{configuration: #{configuration.options_values.inspect}}") if configuration.debug
       nil
     end
 
@@ -29,8 +29,10 @@ module Uncov
 
   class ConfigurationError < Error; end
   class GitError < Error; end
-  class SimpleCovError < Error; end
+  class FinderError < Error; end
+  class SimpleCovError < FinderError; end
   class FormatterError < Error; end
+  class ReportError < Error; end
   class OptionValueNotAllowed < ConfigurationError; end
 
   class NotGitRepoError < GitError
@@ -40,11 +42,18 @@ module Uncov
     def message = "#{path.inspect} is not in a git working tree"
   end
 
-  class NotGitBranchError < GitError
+  class NotGitObjectError < 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"
+    def message = "Git target #{target_branch.inspect} not found locally"
+  end
+
+  class UnsupportedSimpleCovTriggerError < FinderError
+    attr_reader :trigger
+
+    def initialize(trigger) = @trigger = trigger
+    def message = "#{trigger.inspect} is not a supported simple_cov_trigger type"
   end
 
   class FailedToGenerateReport < SimpleCovError
@@ -68,4 +77,11 @@ module Uncov
     def initialize(output_format) = @output_format = output_format
     def message = "#{output_format.inspect} is not a supported formatter"
   end
+
+  class UnsupportedReportTypeError < ReportError
+    attr_reader :type
+
+    def initialize(type) = @type = type
+    def message = "#{type.inspect} is not a supported report type"
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uncov
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Michał Papis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-10 00:00:00.000000000 Z
+date: 2025-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -111,9 +111,13 @@ files:
 - 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/report/generator.rb
+- lib/uncov/report/generator/diff_files.rb
+- lib/uncov/report/generator/diff_lines.rb
+- lib/uncov/report/generator/git_files.rb
+- lib/uncov/report/generator/nocov_lines.rb
 - lib/uncov/struct.rb
 - lib/uncov/version.rb
 homepage: https://github.com/mpapis/uncov