uncov 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 328d5a3a593abb320621afee6841e28c19be46fd4ea1092ae52d6ef513131469
-  data.tar.gz: ba6658737c8230c2f90dd045a568c478dbee86d782d57c5c75e9f0d9303eb796
+  metadata.gz: 2f557524930fea642ca504cc2bfccfc99c7b865b930d42edcbbd76f01ec8013a
+  data.tar.gz: 5522f0f4b1c899e48c0b4f5ff7cc78a69005adc36d648f1f554a1778c9045eb4
 SHA512:
-  metadata.gz: abba73e5527b9f48108ecd90757036af35f4dd4f9a8b2c2399e7e9c9c804a5d99195bcc0f6d9117583f5f07e9efa2e94db15ccd3b3f3829c09629dcc9bcac57e
-  data.tar.gz: fdb66c5ff19eb0c3bcacb136147a3d3493ed44400602c071137b91fdc1edacbef6ef6fe13663aa05ae24c9cd68ac773b95080466aed1e4026de6b52a3bcf0a2b
+  metadata.gz: 1ea2690f56426f9c50f1d9fa05597cbf86e3c67b3eff3ecbafbcb05b8c1901588b845bfd6e14798dae35355410ff68df2305073883d556cb17c5b6a66f9734c4
+  data.tar.gz: 71abb30813bf499aeb08f7126fc19b2d765645df8e7e4704c006083dedcb37f270401d098dee557ef345da5c72aac43494aa65c6a02d95af28c17d5b7b2b7166

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 2025-05-31: [v0.6.1](https://github.com/mpapis/uncov/releases/tag/v0.6.1)
+
+### Patch
+
+- [#63](https://github.com/mpapis/uncov/pull/63): Improve filesystem performance, by [@mpapis](https://github.com/mpapis)
+
+
+## 2025-05-26: [v0.6.0](https://github.com/mpapis/uncov/releases/tag/v0.6.0)
+
+### Minor
+
+- [#47](https://github.com/mpapis/uncov/pull/47): Extensible with plugins, by [@mpapis](https://github.com/mpapis)
+- [#56](https://github.com/mpapis/uncov/pull/56): Add Simplecov and FileSystem filters, by [@mpapis](https://github.com/mpapis)
+
+### Patch
+
+- [#59](https://github.com/mpapis/uncov/pull/59): Simplify git rev-parse target, by [@mpapis](https://github.com/mpapis)
+
+
 ## 2025-05-12: [v0.5.0](https://github.com/mpapis/uncov/releases/tag/v0.5.0)
 
 ### Minor

data/CONTRIBUTING.md

@@ -12,7 +12,7 @@ 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,
+- `docker-compose run --rm uncov` to enter dev container,
 - `bundle` to install dependencies and uncov,
 - `rake` to run lint, test and uncov - **precheck** before opening PR,
 - `uncov` to test manually

data/README.md

@@ -13,6 +13,8 @@ Uncov uses `git diff` to detect changes and `simplecov` reports to detect uncove
 - Identify changed Ruby files
 - Run tests automatically for (changed) relevant files
 - Print report of uncovered lines in (changed) files
+- Print report of covered :nocov: lines in (changed) files
+- Extensible with gem plugins
 
 
 ## Installation
@@ -36,8 +38,8 @@ uncov
 $ uncov -h
 Usage: uncov [options]
     -t, --target TARGET              Target branch for comparison, default: "HEAD"
-    -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)
+    -r, --report FILTER              Report filter to generate file/line list, one_of: "DiffFiles", "DiffLines"(default), "FileSystem", "GitFiles", "NocovLines", "Simplecov"
+    -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"
@@ -49,10 +51,12 @@ Usage: uncov [options]
     -h, --help                       Print this help
 
 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
+ DiffFiles - Report missing coverage on added/changed files in the git diff
+ DiffLines - Report missing coverage on added lines in the git diff
+FileSystem - Report missing coverage on file system
+  GitFiles - Report missing coverage on files tracked with git
+NocovLines - Report coverage on nocov lines, requires one or both: --nocov-ignore / --nocov-covered
+ Simplecov - Report missing coverage on files tracked with simplecov
 
 Report FILTERs take NOTICE:
 git*/diff*  - filters will not consider new files unless added to the git index with `git add`.
@@ -62,7 +66,7 @@ nocov*      - filters/flags only work with coverage/.resultset.json SimpleCov fi
 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>
+uncov 0.6.1 by Michal Papis <mpapis@gmail.com>
 ```
 
 
@@ -79,6 +83,16 @@ COVERAGE=1 rspec
 ```
 
 
+## Plugins
+Uncov uses [pluginator](https://github.com/rvm/pluginator) to load plugins.
+
+See [lib/plugins/uncov](lib/plugins/uncov) for default plugins.
+
+To create your own plugin, create a gem with a `lib/plugins/uncov/...` structure - same as uncov has,
+the plugins will be loaded automatically.
+
+When you use uncov from a Gemfile then the new gam has to be added there too.
+
 ## 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.

data/lib/{uncov → plugins/uncov}/formatter/terminal.rb

@@ -13,15 +13,16 @@ class Uncov::Formatter::Terminal
   end
 
   def output
-    puts "Found #{report.display_files.size} files with uncovered changes:".yellow
+    return puts 'No files to report.'.green if report.files.empty?
+    return puts "All changed files(#{report.files.count}) have 100% test coverage!".green unless report.trigger?
+
+    output_header
     output_files
-    puts
-    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
+    output_summary
+  end
+
+  def output_header
+    puts "Files with uncovered changes: (#{report.display_files.size} / #{report.files.count})".yellow
   end
 
   def output_files
@@ -70,4 +71,14 @@ class Uncov::Formatter::Terminal
   def number_length(file_coverage)
     file_coverage.display_lines.last.number.to_s.length
   end
+
+  def output_summary
+    puts
+    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
 end

data/lib/plugins/uncov/report/filters/diff_files.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# report only files lines from the diff
+module Uncov::Report::Filters::DiffFiles
+  class << self
+    def description = 'Report missing coverage on added/changed files in the git diff'
+    def simplecov_trigger = :git_diff
+
+    def files(finder)
+      finder.git_diff_files.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)
+      Uncov::Report::Context.add_context(finder, file_name, lines_hash)
+      lines_hash.sort.to_h.values
+    end
+
+    def file_lines(finder, file_name)
+      finder.file_system_files.lines(file_name).keys.to_h do |line_number|
+        [line_number, finder.build_line(file_name, line_number)]
+      end
+    end
+  end
+end

data/lib/plugins/uncov/report/filters/diff_lines.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# report only files lines from the diff
+module Uncov::Report::Filters::DiffLines
+  class << self
+    def description = 'Report missing coverage on added lines in the git diff'
+    def simplecov_trigger = :git_diff
+
+    def files(finder)
+      finder.git_diff_files.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 = git_diff_files_lines(finder, file_name)
+      Uncov::Report::Context.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_files.lines(file_name).keys.to_h do |line_number|
+        [line_number, finder.build_line(file_name, line_number)]
+      end
+    end
+  end
+end

data/lib/plugins/uncov/report/filters/file_system.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# report all files lines from the file system
+module Uncov::Report::Filters::FileSystem
+  class << self
+    def description = 'Report missing coverage on file system'
+    def simplecov_trigger = :file_system
+
+    def files(finder)
+      finder.file_system_files.file_names.map do |file_name|
+        Uncov::Report::File.new(
+          file_name:,
+          git: finder.git_files.file?(file_name),
+          lines: lines(finder, file_name)
+        )
+      end
+    end
+
+    private
+
+    def lines(finder, file_name)
+      lines_hash = file_lines(finder, file_name)
+      Uncov::Report::Context.add_context(finder, file_name, lines_hash)
+      lines_hash.sort.to_h.values
+    end
+
+    def file_lines(finder, file_name)
+      finder.file_system_files.lines(file_name).keys.to_h do |line_number|
+        [line_number, finder.build_line(file_name, line_number)]
+      end
+    end
+  end
+end

data/lib/plugins/uncov/report/filters/git_files.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# report only files lines from the diff
+module Uncov::Report::Filters::GitFiles
+  class << self
+    def description = 'Report missing coverage on files tracked with git'
+    def simplecov_trigger = :git
+
+    def files(finder)
+      finder.git_files.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)
+      Uncov::Report::Context.add_context(finder, file_name, lines_hash)
+      lines_hash.sort.to_h.values
+    end
+
+    def file_lines(finder, file_name)
+      finder.file_system_files.lines(file_name).keys.to_h do |line_number|
+        [line_number, finder.build_line(file_name, line_number)]
+      end
+    end
+  end
+end

data/lib/plugins/uncov/report/filters/nocov_lines.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# report only files lines from the diff
+module Uncov::Report::Filters::NocovLines
+  class << self
+    def description = 'Report coverage on nocov lines, requires one or both: --nocov-ignore / --nocov-covered'
+    def simplecov_trigger = :file_system
+
+    def files(finder)
+      finder.nocov_files.file_names.filter_map do |file_name|
+        next if finder.nocov_files.lines(file_name).empty?
+
+        Uncov::Report::File.new(
+          file_name:,
+          git: finder.git_files.file?(file_name),
+          lines: lines(finder, file_name)
+        )
+      end
+    end
+
+    private
+
+    def lines(finder, file_name)
+      lines_hash = nocov_files_lines(finder, file_name)
+      Uncov::Report::Context.add_context(finder, file_name, lines_hash)
+      lines_hash.sort.to_h.values
+    end
+
+    def nocov_files_lines(finder, file_name)
+      finder.nocov_files.lines(file_name).keys.to_h do |line_number|
+        [line_number, finder.build_line(file_name, line_number)]
+      end
+    end
+  end
+end

data/lib/plugins/uncov/report/filters/simplecov.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# report only files lines from the simplecov
+module Uncov::Report::Filters::Simplecov
+  class << self
+    def description = 'Report missing coverage on files tracked with simplecov'
+    def simplecov_trigger = :file_system
+
+    def files(finder)
+      finder.simplecov_files.file_names.map do |file_name|
+        Uncov::Report::File.new(
+          file_name:,
+          git: finder.git_files.file?(file_name),
+          lines: lines(finder, file_name)
+        )
+      end
+    end
+
+    private
+
+    def lines(finder, file_name)
+      lines_hash = file_lines(finder, file_name)
+      Uncov::Report::Context.add_context(finder, file_name, lines_hash)
+      lines_hash.sort.to_h.values
+    end
+
+    def file_lines(finder, file_name)
+      finder.file_system_files.lines(file_name).keys.to_h do |line_number|
+        [line_number, finder.build_line(file_name, line_number)]
+      end
+    end
+  end
+end

data/lib/uncov/configuration.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'formatter'
-require_relative 'report/generator'
+require_relative 'report/filters'
 
 # handle configuration for uncov
 class Uncov::Configuration
@@ -21,9 +21,9 @@ class Uncov::Configuration
 
   option 'target', 'Target branch for comparison', options: ['-t', '--target TARGET'], default: 'HEAD'
   option 'report', 'Report filter to generate file/line list',
-         options: ['-r', '--report FILTER'], default: 'diff_lines', allowed_values: -> { Uncov::Report::Generator.filters.keys }
+         options: ['-r', '--report FILTER'], default: 'DiffLines', allowed_values: -> { Uncov::Report::Filters.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.formatters.keys }
   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',
@@ -101,9 +101,9 @@ class Uncov::Configuration
   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]}"
+    report_type_length = Uncov::Report::Filters.filters.keys.map(&:length).max
+    Uncov::Report::Filters.filters.map do |name, filter|
+      format("%#{report_type_length}s - %s", name, filter.description)
     end.join("\n")
   end
 

data/lib/uncov/finder/file_system.rb

@@ -4,25 +4,33 @@
 class Uncov::Finder::FileSystem
   include Uncov::Cache
 
-  def files
-    all_files.to_h do |file_name|
-      [file_name, lines(file_name)]
+  def code_files
+    cache(:code_files) do
+      list_files(Uncov.configuration.relevant_files).to_h do |file_name|
+        [file_name, read_lines(file_name)]
+      end
     end
   end
 
+  def simplecov_trigger_files
+    code_files.keys + test_files
+  end
+
   private
 
-  def all_files
-    Dir.glob(Uncov.configuration.relevant_files, Uncov::Configuration::FILE_MATCH_FLAGS).select { |f| File.file?(f) }
+  def test_files
+    cache(:test_files) do
+      list_files(Uncov.configuration.relevant_tests)
+    end
   end
 
-  def lines(file_name)
-    cache(file_name) do
-      read_lines(file_name)
-    end
+  def list_files(glob)
+    Dir.glob(glob, Uncov::Configuration::FILE_MATCH_FLAGS).select { |f| File.file?(f) }
   end
 
   def read_lines(file_name)
-    File.readlines(file_name).each_with_index.to_h { |line, line_index| [line_index + 1, line.rstrip] }
+    lines = {}
+    File.foreach(file_name).with_index(1) { |line, idx| lines[idx] = line.chomp }
+    lines
   end
 end

data/lib/uncov/finder/files.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# wrap finder results to have the same interface as finder
+class Uncov::Finder::Files
+  attr_reader :files
+
+  def initialize(files)
+    @files = files
+  end
+
+  def file?(file_name)
+    @files.key?(file_name)
+  end
+
+  def file_names
+    @files.keys
+  end
+
+  def lines(file_name)
+    @files[file_name] || {}
+  end
+
+  def line(file_name, line_number)
+    @files.dig(file_name, line_number)
+  end
+
+  def line?(file_name, line_number)
+    lines(file_name)&.key?(line_number)
+  end
+end

data/lib/uncov/finder/git.rb

@@ -14,16 +14,20 @@ class Uncov::Finder::Git
     end
   end
 
+  def simplecov_trigger_files
+    code_files.keys + test_files
+  end
+
+  private
+
   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
+      all_file_names.select do |file_name|
+        relevant_test_file?(file_name)
+      end
     end
   end
 
-  private
-
   def all_file_names
     cache(:all_files) do
       open_repo.ls_files.keys

data/lib/uncov/finder/git_diff.rb

@@ -15,16 +15,20 @@ class Uncov::Finder::GitDiff
     end
   end
 
+  def simplecov_trigger_files
+    code_files.keys + test_files
+  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
+        file_diff.path if relevant_test_file?(file_diff.path) && File.exist?(file_diff.path)
+      end
     end
   end
 
-  private
-
   def all_files_diff
     cache(:all_files) do
       git_diff
@@ -43,15 +47,10 @@ class Uncov::Finder::GitDiff
 
   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)
+    git_target = repo.rev_parse(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:
+  rescue Git::FailedError
+    raise Uncov::NotGitObjectError, target
   end
 
   def target

data/lib/uncov/finder/{no_cov.rb → nocov.rb}

@@ -1,24 +1,16 @@
 # frozen_string_literal: true
 
 # collect nocov information from files
-class Uncov::Finder::NoCov
-  include Uncov::Cache
-
+class Uncov::Finder::Nocov
   def files(all_files)
-    all_files.to_h do |file_name, lines|
-      [file_name, nocov_lines(file_name, lines)]
+    all_files.files.transform_values do |lines|
+      nocov_lines(lines)
     end
   end
 
   private
 
-  def nocov_lines(file_name, lines)
-    cache(file_name) do
-      read_nocov(lines)
-    end
-  end
-
-  def read_nocov(lines)
+  def nocov_lines(lines)
     nocov = false
     lines.filter_map do |number, line|
       line_nocov = line.strip.start_with?('# :nocov:')

data/lib/uncov/finder/{simple_cov.rb → simplecov.rb}

@@ -3,7 +3,7 @@
 require 'json'
 
 # collect coverage information, regenerates report if any trigger_files are newer then the report
-module Uncov::Finder::SimpleCov
+module Uncov::Finder::Simplecov
   class << self
     def files(trigger_files)
       regenerate_report if requires_regeneration?(trigger_files)
@@ -67,9 +67,9 @@ module Uncov::Finder::SimpleCov
     def raise_on_missing_coverage_path!
       return if coverage_path && File.exist?(coverage_path)
 
-      raise Uncov::AutodetectSimpleCovPathError if Uncov.configuration.simplecov_file == 'autodetect'
+      raise Uncov::AutodetectSimplecovPathError if Uncov.configuration.simplecov_file == 'autodetect'
 
-      raise Uncov::MissingSimpleCovReport, coverage_path
+      raise Uncov::MissingSimplecovReport, coverage_path
     end
   end
 end

data/lib/uncov/finder.rb

@@ -4,94 +4,79 @@
 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_lines(file_name) = git_diff_files[file_name]
-  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:,
-      git_diff_test_files:,
-      file_system_files:,
-      no_cov_files:,
-      simple_cov_files:
-    }
+  def initialize(simplecov_trigger)
+    @simplecov_trigger = simplecov_trigger
   end
 
-  private
-
-  attr_reader :simple_cov_trigger
-
-  def git_files
-    git_finder.code_files
+  def build_line(file_name, line_number, context: false)
+    Uncov::Report::File::Line.new(
+      number: line_number,
+      content: file_system_files.line(file_name, line_number),
+      nocov: nocov_files.line(file_name, line_number),
+      simplecov: simplecov_files.line(file_name, line_number),
+      git_diff: git_diff_files.line?(file_name, line_number),
+      context:
+    )
   end
 
-  def git_test_files
-    git_finder.test_files
+  def file_system_files
+    Uncov::Finder::Files.new(file_system_finder.code_files)
   end
 
-  def git_finder
-    cache(:git_finder) do
-      Uncov::Finder::Git.new
-    end
+  def git_files
+    Uncov::Finder::Files.new(git_finder.code_files)
   end
 
   def git_diff_files
-    git_diff_finder.code_files
+    Uncov::Finder::Files.new(git_diff_finder.code_files)
   end
 
-  def git_diff_test_files
-    git_diff_finder.test_files
+  def nocov_files
+    cache(:nocov_files) do
+      Uncov::Finder::Files.new(Uncov::Finder::Nocov.new.files(file_system_files))
+    end
   end
 
-  def git_diff_finder
-    cache(:git_diff_finder) do
-      Uncov::Finder::GitDiff.new
+  def simplecov_files
+    cache(:simplecov_files) do
+      Uncov::Finder::Files.new(Uncov::Finder::Simplecov.files(simplecov_trigger_files))
     end
   end
 
-  def file_system_files
-    cache(:file_system_files) do
-      Uncov::Finder::FileSystem.new.files
+  private
+
+  attr_reader :simplecov_trigger
+
+  def file_system_finder
+    cache(:file_system_finder) do
+      Uncov::Finder::FileSystem.new
     end
   end
 
-  def no_cov_files
-    cache(:no_cov_files) do
-      Uncov::Finder::NoCov.new.files(file_system_files)
+  def git_finder
+    cache(:git_finder) do
+      Uncov::Finder::Git.new
     end
   end
 
-  def simple_cov_files
-    cache(:simple_cov_files) do
-      Uncov::Finder::SimpleCov.files(simple_cov_trigger_files)
+  def git_diff_finder
+    cache(:git_diff_finder) do
+      Uncov::Finder::GitDiff.new
     end
   end
 
-  def simple_cov_trigger_files
-    case simple_cov_trigger
+  def simplecov_trigger_files
+    case simplecov_trigger
     when :git
-      git_file_names + git_test_files.keys
+      git_finder
     when :git_diff
-      git_diff_file_names + git_diff_test_files.keys
+      git_diff_finder
     when :file_system
-      file_system_file_names
+      file_system_finder
     else
       # :nocov:
-      raise Uncov::UnsupportedSimpleCovTriggerError, simple_cov_trigger
+      raise Uncov::UnsupportedSimplecovTriggerError, simplecov_trigger
       # :nocov:
-    end
+    end.simplecov_trigger_files
   end
 end

data/lib/uncov/formatter.rb

@@ -3,27 +3,14 @@
 # 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.trigger?
-        return puts "All changed files(#{report.files.count}) have 100% test coverage!".green
-      end
-
-      output_report(report)
+    def formatters
+      @formatters ||= Uncov.plugins.plugins_map('formatter')
     end
 
-    private
+    def output(report)
+      raise Uncov::UnsupportedFormatterError, Uncov.configuration.output_format unless formatters.key?(Uncov.configuration.output_format)
 
-    def output_report(report)
-      case Uncov.configuration.output_format
-      when 'terminal'
-        Uncov::Formatter::Terminal.new(report).output
-      else
-        raise Uncov::UnsupportedFormatterError, Uncov.configuration.output_format
-      end
+      formatters[Uncov.configuration.output_format].new(report).output
     end
   end
 end

data/lib/uncov/report/context.rb

@@ -4,6 +4,20 @@
 # @return [Integer] only added context lines matching all_line_numbers and not in important_line_numbers
 module Uncov::Report::Context
   class << self
+    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_files.lines(file_name).keys
+      context_line_numbers = calculate(all_line_numbers, line_numbers, Uncov.configuration.context)
+      context_line_numbers.each do |line_number|
+        mark_context_line(finder, file_name, lines_hash, line_number)
+      end
+    end
+
     def calculate(all_line_numbers, important_line_number, context)
       context_line_numbers = {}
       important_line_number.each do |line_number|
@@ -14,5 +28,15 @@ module Uncov::Report::Context
       end
       (context_line_numbers.keys.sort & all_line_numbers) - important_line_number
     end
+
+    private
+
+    def mark_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] = finder.build_line(file_name, line_number, context: true)
+      end
+    end
   end
 end

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

@@ -1,28 +1,28 @@
 # frozen_string_literal: true
 
 # 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
+class Uncov::Report::File::Line < Uncov::Struct.new(:number, :content, :simplecov, :nocov, :context, :git_diff)
+  def nocov
     return false if Uncov.configuration.nocov_ignore
 
-    self[:no_cov]
+    self[:nocov]
   end
 
   def uncov?
-    simple_cov == false && !no_cov
+    simplecov == false && !nocov
   end
 
   def nocov_covered?
     # :nocov
-    Uncov.configuration.nocov_covered && simple_cov == true && self[:no_cov]
+    Uncov.configuration.nocov_covered && simplecov == true && self[:nocov]
     # :nocov
   end
 
   def covered?
-    return false if Uncov.configuration.nocov_ignore && self[:no_cov]
+    return false if Uncov.configuration.nocov_ignore && self[:nocov]
 
-    (simple_cov == true && !no_cov) ||
-      (Uncov.configuration.nocov_covered && simple_cov == false && self[:no_cov])
+    (simplecov == true && !nocov) ||
+      (Uncov.configuration.nocov_covered && simplecov == false && self[:nocov])
   end
 
   def trigger?

data/lib/uncov/report/filters.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'pluginator'
+require_relative '../report'
+
+# generate report files and lines for the configured report type
+module Uncov::Report::Filters
+  class << self
+    def filters
+      @filters ||= Uncov.plugins.plugins_map('report/filters')
+    end
+
+    def files
+      raise Uncov::UnsupportedReportTypeError, Uncov.configuration.report unless filters.key?(Uncov.configuration.report)
+
+      filter = filters[Uncov.configuration.report]
+      filter.files(Uncov::Finder.new(filter.simplecov_trigger))
+    end
+  end
+end

data/lib/uncov/report.rb

@@ -9,7 +9,7 @@ class Uncov::Report < Uncov::Struct.new(:files)
 
   class << self
     def generate
-      new(files: Uncov::Report::Generator.generate)
+      new(files: Uncov::Report::Filters.files)
     end
   end
 

data/lib/uncov/version.rb

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

data/lib/uncov.rb

@@ -21,6 +21,10 @@ module Uncov
     def configuration_reset!
       @configuration = Configuration.new
     end
+
+    def plugins
+      @plugins ||= Pluginator.find('uncov', extends: ['plugins_map'])
+    end
   end
 
   class Error < StandardError
@@ -30,7 +34,7 @@ module Uncov
   class ConfigurationError < Error; end
   class GitError < Error; end
   class FinderError < Error; end
-  class SimpleCovError < FinderError; end
+  class SimplecovError < FinderError; end
   class FormatterError < Error; end
   class ReportError < Error; end
   class OptionValueNotAllowed < ConfigurationError; end
@@ -49,25 +53,25 @@ module Uncov
     def message = "Git target #{target_branch.inspect} not found locally"
   end
 
-  class UnsupportedSimpleCovTriggerError < FinderError
+  class UnsupportedSimplecovTriggerError < FinderError
     attr_reader :trigger
 
     def initialize(trigger) = @trigger = trigger
-    def message = "#{trigger.inspect} is not a supported simple_cov_trigger type"
+    def message = "#{trigger.inspect} is not a supported simplecov_trigger type"
   end
 
-  class FailedToGenerateReport < SimpleCovError
+  class FailedToGenerateReport < SimplecovError
     def message = cause.message
   end
 
-  class MissingSimpleCovReport < SimpleCovError
+  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 AutodetectSimpleCovPathError < SimpleCovError
+  class AutodetectSimplecovPathError < SimplecovError
     def message = 'Could not autodetect coverage report path'
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uncov
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Michał Papis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-12 00:00:00.000000000 Z
+date: 2025-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: git_diff_parser
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pluginator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
 description: uncov compares your current branch with a target branch, identifies changed
   files, and reports on test coverage for those changes
 email:
@@ -95,6 +109,13 @@ files:
 - PHILOSOPHY.md
 - README.md
 - bin/uncov
+- lib/plugins/uncov/formatter/terminal.rb
+- lib/plugins/uncov/report/filters/diff_files.rb
+- lib/plugins/uncov/report/filters/diff_lines.rb
+- lib/plugins/uncov/report/filters/file_system.rb
+- lib/plugins/uncov/report/filters/git_files.rb
+- lib/plugins/uncov/report/filters/nocov_lines.rb
+- lib/plugins/uncov/report/filters/simplecov.rb
 - lib/uncov.rb
 - lib/uncov/cache.rb
 - lib/uncov/cli.rb
@@ -102,22 +123,18 @@ files:
 - lib/uncov/configuration/option.rb
 - lib/uncov/finder.rb
 - lib/uncov/finder/file_system.rb
+- lib/uncov/finder/files.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/finder/nocov.rb
+- lib/uncov/finder/simplecov.rb
 - lib/uncov/formatter.rb
-- lib/uncov/formatter/terminal.rb
 - lib/uncov/report.rb
 - lib/uncov/report/context.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/report/filters.rb
 - lib/uncov/struct.rb
 - lib/uncov/version.rb
 homepage: https://github.com/mpapis/uncov

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

@@ -1,57 +0,0 @@
-# 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/generator/diff_lines.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-# report only files lines from the diff
-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|
-        Uncov::Report::File.new(
-          file_name:,
-          git: true,
-          lines: lines(finder, file_name)
-        )
-      end
-    end
-
-    private
-
-    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)
-      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/git_files.rb

@@ -1,57 +0,0 @@
-# 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

@@ -1,67 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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