uncov 0.4.2 → 0.6.0

data/lib/uncov/finder/git_diff.rb

@@ -4,41 +4,56 @@ 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 simplecov_trigger_files
+    code_files.keys + test_files
+  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 test_files
+    cache(:test_files) do
+      all_files_diff.filter_map do |file_diff|
+        file_diff.path if relevant_test_file?(file_diff.path) && File.exist?(file_diff.path)
+      end
     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)
+  def all_files_diff
+    cache(:all_files) do
+      git_diff
     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] == '+'
+
+        [changed_line.number, nil]
+      end
+    end.compact.to_h
+  end
+
+  def git_diff
+    repo = open_repo
+    git_target = repo.rev_parse(target)
+    repo.diff(git_target)
+  rescue Git::FailedError
+    raise Uncov::NotGitObjectError, target
+  end
 
-    def target = Uncov.configuration.target
+  def target
+    Uncov.configuration.target
   end
 end

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

@@ -1,20 +1,18 @@
 # 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 { |file_name, lines| [file_name, nocov_proc(file_name, lines)] }
+    all_files.files.transform_values do |lines|
+      nocov_lines(lines)
+    end
   end
 
   private
 
-  def nocov_proc(file_name, lines_proc) = -> { cache(file_name) { read_nocov(lines_proc) } }
-
-  def read_nocov(lines_proc)
+  def nocov_lines(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 → simplecov.rb}

@@ -3,23 +3,38 @@
 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)
       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
@@ -52,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,43 +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_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)
-
-  def debug
-    {
-      git_files:,
-      git_diff_files:,
-      file_system_files: file_system_files.transform_values(&:call),
-      no_cov_files: no_cov_files.transform_values(&:call),
-      simple_cov_files:
-    }
+  def initialize(simplecov_trigger)
+    @simplecov_trigger = simplecov_trigger
+  end
+
+  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 file_system_files
+    Uncov::Finder::Files.new(file_system_finder.code_files)
+  end
+
+  def git_files
+    Uncov::Finder::Files.new(git_finder.code_files)
+  end
+
+  def git_diff_files
+    Uncov::Finder::Files.new(git_diff_finder.code_files)
+  end
+
+  def nocov_files
+    cache(:nocov_files) do
+      Uncov::Finder::Files.new(Uncov::Finder::Nocov.new.files(file_system_files))
+    end
+  end
+
+  def simplecov_files
+    cache(:simplecov_files) do
+      Uncov::Finder::Files.new(Uncov::Finder::Simplecov.files(simplecov_trigger_files))
+    end
   end
 
   private
 
-  attr_reader :simple_cov_trigger
+  attr_reader :simplecov_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 file_system_finder
+    cache(:file_system_finder) do
+      Uncov::Finder::FileSystem.new
+    end
+  end
 
-  def simple_cov_trigger_files
-    case simple_cov_trigger
+  def git_finder
+    cache(:git_finder) do
+      Uncov::Finder::Git.new
+    end
+  end
+
+  def git_diff_finder
+    cache(:git_diff_finder) do
+      Uncov::Finder::GitDiff.new
+    end
+  end
+
+  def simplecov_trigger_files
+    case simplecov_trigger
     when :git
-      git_file_names
+      git_finder
     when :git_diff
-      git_diff_file_names
-    end
+      git_diff_finder
+    when :file_system
+      file_system_finder
+    else
+      # :nocov:
+      raise Uncov::UnsupportedSimplecovTriggerError, simplecov_trigger
+      # :nocov:
+    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.uncov?
-        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,20 +1,39 @@
 # 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)
+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[:nocov]
+  end
+
   def uncov?
-    simple_cov == false && !no_cov
+    simplecov == false && !nocov
+  end
+
+  def nocov_covered?
+    # :nocov
+    Uncov.configuration.nocov_covered && simplecov == true && self[:nocov]
+    # :nocov
   end
 
   def covered?
-    simple_cov == true && !no_cov
+    return false if Uncov.configuration.nocov_ignore && self[:nocov]
+
+    (simplecov == true && !nocov) ||
+      (Uncov.configuration.nocov_covered && simplecov == false && self[:nocov])
+  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/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

@@ -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::Filters.files)
     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.6.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
 
@@ -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
@@ -29,8 +33,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,25 +46,32 @@ 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 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
 
@@ -68,4 +81,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