single_cov 1.3.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2cf305464b1da18b681573d4e895ba407a3205665d17b2a6ebb344dfcf53d0c
-  data.tar.gz: baaf64ed79b78aaea3b4d19a60d4f068f38bee2473dae5ec7ac7a85392e8b05d
+  metadata.gz: b1061e2ee0841966f31a082926db0474550414ac8e06f395696152ba3b985aa5
+  data.tar.gz: 836d974a4b39cbbf4b5454334997f60ac4d2afe5aafd4609bc2e04fb57f5a991
 SHA512:
-  metadata.gz: 9c78ebf762c39a959945fba05bea127029d9594dcdf973e146e47ad9a5d1070e1db4196c2deac23e1c8ce44c886547b25e5f092f19f7b2643fe3b8611f67afab
-  data.tar.gz: 96633f2c63bd2e512a57e45130ce71aacc5d16f4e1636f77be274bfe405be9526728c69ab4d6d14bf9db5a13805cd30ccb6e47690f73db522df52c450d7c7ee2
+  metadata.gz: e30055d56774315c96b907ef0d930c83a4ac921855d0000760ade00d47af0e3394a96853f13f669e4fd797e0d8d2d5aeadbfb1e8a8549f45ca36629a80befae6
+  data.tar.gz: 6e42c196b4cbb0eccb982b3bb942cf1664d8aa99925eabc7c9fb6165d10dd94de36640527556a9209739058501a36e191fc9136f21c903e0aa57307c63b2bd73

data/lib/single_cov.rb

@@ -1,75 +1,63 @@
+# frozen_string_literal: true
 module SingleCov
   COVERAGES = []
   MAX_OUTPUT = 40
-  APP_FOLDERS = ["models", "serializers", "helpers", "controllers", "mailers", "views", "jobs", "channels"]
-  BRANCH_COVERAGE_SUPPORTED = (RUBY_VERSION >= "2.5.0")
-  UNCOVERED_COMMENT_MARKER = "uncovered"
+  RAILS_APP_FOLDERS = ["models", "serializers", "helpers", "controllers", "mailers", "views", "jobs", "channels"]
+  UNCOVERED_COMMENT_MARKER = /#.*uncovered/
 
   class << self
-    # optionally rewrite the file we guessed with a lambda
+    # enable coverage reporting: path to output file, changed by forking-test-runner at runtime to combine many reports
+    attr_accessor :coverage_report
+
+    # emit only line coverage in coverage report for older coverage systems
+    attr_accessor :coverage_report_lines
+
+    # optionally rewrite the matching path single-cov guessed with a lambda
     def rewrite(&block)
       @rewrite = block
     end
 
+    # mark a test file as not covering anything to make assert_used pass
     def not_covered!
-      store_pid
+      main_process!
     end
 
+    # mark the file under test as needing coverage
     def covered!(file: nil, uncovered: 0)
-      file = guess_and_check_covered_file(file)
+      file = ensure_covered_file(file)
       COVERAGES << [file, uncovered]
-      store_pid
+      main_process!
     end
 
     def all_covered?(result)
-      errors = COVERAGES.map do |file, expected_uncovered|
-        if coverage = result["#{root}/#{file}"]
-          line_coverage = (coverage.is_a?(Hash) ? coverage.fetch(:lines) : coverage)
-          uncovered = line_coverage.each_with_index.map { |c, i| i + 1 if c == 0 }.compact
-          branch_coverage = (coverage.is_a?(Hash) && coverage[:branches])
-
-          if branch_coverage
-            uncovered.concat uncovered_branches(branch_coverage, uncovered)
-          end
+      errors = COVERAGES.flat_map do |file, expected_uncovered|
+        next no_coverage_error(file) unless coverage = result["#{root}/#{file}"]
 
-          next if uncovered.size == expected_uncovered
-
-          # ignore lines that are marked as uncovered via comments
-          # NOTE: ideally we should also warn when using uncovered but the section is indeed covered
-          content = File.readlines(file)
-          uncovered.reject! do |line_start, _, _, _|
-            content[line_start - 1].include?(UNCOVERED_COMMENT_MARKER)
-          end
+        uncovered = uncovered(coverage)
+        next if uncovered.size == expected_uncovered
 
-          next if uncovered.size == expected_uncovered
-
-          # branches are unsorted and added to the end, only sort when necessary
-          if branch_coverage
-            uncovered.sort_by! { |line_start, char_start, _, _| [line_start, char_start || 0] }
-          end
-
-          uncovered.map! do |line_start, char_start, line_end, char_end|
-            char_start ? "#{file}:#{line_start}:#{char_start}-#{line_end}:#{char_end}" : "#{file}:#{line_start}"
-          end
-
-          warn_about_bad_coverage(file, expected_uncovered, uncovered)
-        else
-          warn_about_no_coverage(file)
+        # ignore lines that are marked as uncovered via comments
+        # TODO: warn when using uncovered but the section is indeed covered
+        content = File.readlines(file)
+        uncovered.reject! do |line_start, _, _, _|
+          content[line_start - 1].match?(UNCOVERED_COMMENT_MARKER)
         end
+        next if uncovered.size == expected_uncovered
+
+        bad_coverage_error(file, expected_uncovered, uncovered)
       end.compact
 
       return true if errors.empty?
 
-      errors = errors.join("\n").split("\n") # unify arrays with multiline strings
       errors[MAX_OUTPUT..-1] = "... coverage output truncated" if errors.size >= MAX_OUTPUT
       warn errors
 
-      errors.all? { |l| l.end_with?('?') } # ok if we just have warnings
+      errors.all? { |l| warning?(l) }
     end
 
     def assert_used(tests: default_tests)
       bad = tests.select do |file|
-        File.read(file) !~ /SingleCov.(not_)?covered\!/
+        File.read(file) !~ /SingleCov.(not_)?covered!/
       end
       unless bad.empty?
         raise bad.map { |f| "#{f}: needs to use SingleCov.covered!" }.join("\n")
@@ -77,7 +65,7 @@ module SingleCov
     end
 
     def assert_tested(files: glob('{app,lib}/**/*.rb'), tests: default_tests, untested: [])
-      missing = files - tests.map { |t| file_under_test(t) }
+      missing = files - tests.map { |t| guess_covered_file(t) }
       fixed = untested - missing
       missing -= untested
 
@@ -88,13 +76,10 @@ module SingleCov
       end
     end
 
-    def setup(framework, root: nil, branches: BRANCH_COVERAGE_SUPPORTED)
+    def setup(framework, root: nil, branches: true)
       if defined?(SimpleCov)
         raise "Load SimpleCov after SingleCov"
       end
-      if branches && !BRANCH_COVERAGE_SUPPORTED
-        raise "Branch coverage needs ruby >= 2.5.0"
-      end
 
       @branches = branches
       @root = root
@@ -112,7 +97,11 @@ module SingleCov
       start_coverage_recording
 
       override_at_exit do |status, _exception|
-        exit 1 if enabled? && main_process? && status == 0 && !SingleCov.all_covered?(coverage_results)
+        if enabled? && main_process? && status == 0
+          results = coverage_results
+          generate_report results
+          exit 1 unless SingleCov.all_covered?(results)
+        end
       end
     end
 
@@ -123,19 +112,38 @@ module SingleCov
 
     private
 
+    def uncovered(coverage)
+      return coverage unless coverage.is_a?(Hash) # just lines
+
+      # [nil, 1, 0, 1, 0] -> [3, 5]
+      uncovered_lines = coverage.fetch(:lines)
+        .each_with_index
+        .select { |c, _| c == 0 }
+        .map { |_, i| i + 1 }
+        .compact
+
+      uncovered_branches = uncovered_branches(coverage[:branches] || {})
+      uncovered_branches.reject! { |k| uncovered_lines.include?(k[0]) } # remove duplicates
+
+      all = uncovered_lines.concat uncovered_branches
+      all.sort_by! { |line_start, char_start, _, _| [line_start, char_start || 0] } # branches are unsorted
+      all
+    end
+
     def enabled?
       (!defined?(@disabled) || !@disabled)
     end
 
-    def store_pid
-      @pid = Process.pid
+    # assuming that the main process will load all the files, we store it's pid
+    def main_process!
+      @main_process_pid = Process.pid
     end
 
     def main_process?
-      (!defined?(@pid) || @pid == Process.pid)
+      (!defined?(@main_process_pid) || @main_process_pid == Process.pid)
     end
 
-    def uncovered_branches(coverage, uncovered_lines)
+    def uncovered_branches(coverage)
       # {[branch_id] => {[branch_part] => coverage}} --> {branch_part -> sum-of-coverage}
       sum = Hash.new(0)
       coverage.each_value do |branch|
@@ -144,9 +152,8 @@ module SingleCov
         end
       end
 
-      # show missing coverage
-      found = sum.select { |k, v| v.zero? && !uncovered_lines.include?(k[0]) }.
-        map { |k, _| [k[0], k[1]+1, k[2], k[3]+1] }
+      sum.select! { |_, v| v == 0 } # keep missing coverage
+      found = sum.map { |k, _| [k[0], k[1] + 1, k[2], k[3] + 1] }
       found.uniq!
       found
     end
@@ -162,7 +169,12 @@ module SingleCov
     # do not ask for coverage when SimpleCov already does or it conflicts
     def coverage_results
       if defined?(SimpleCov) && (result = SimpleCov.instance_variable_get(:@result))
-        result.original_result
+        result = result.original_result
+        # singlecov 1.18+ puts string "lines" into the result that we cannot read
+        if result.each_value.first.is_a?(Hash)
+          result = result.transform_values { |v| v.transform_keys(&:to_sym) }
+        end
+        result
       else
         Coverage.result
       end
@@ -175,7 +187,7 @@ module SingleCov
       if @branches
         Coverage.start(lines: true, branches: true)
       else
-        Coverage.start
+        Coverage.start(lines: true)
       end
     end
 
@@ -233,7 +245,7 @@ module SingleCov
     end
 
     def rspec_running_subset_of_tests?
-      (ARGV & ['-t', '--tag', '-e', '--example']).any? || ARGV.any? { |a| a =~ /\:\d+$|\[[\d:]+\]$/ }
+      (ARGV & ['-t', '--tag', '-e', '--example']).any? || ARGV.any? { |a| a =~ /:\d+$|\[[\d:]+\]$/ }
     end
 
     # code stolen from SimpleCov
@@ -258,15 +270,13 @@ module SingleCov
       end
     end
 
-    def guess_and_check_covered_file(file)
-      if file && file.start_with?("/")
-        raise "Use paths relative to root."
-      end
+    def ensure_covered_file(file)
+      raise "Use paths relative to project root." if file&.start_with?("/")
 
       if file
-        raise "#{file} does not exist and cannot be covered." unless File.exist?("#{root}/#{file}")
+        raise "#{file} does not exist, use paths relative to project root." unless File.exist?("#{root}/#{file}")
       else
-        file = file_under_test(caller[1])
+        file = guess_covered_file(caller[1])
         if file.start_with?("/")
           raise "Found file #{file} which is not relative to the root #{root}.\nUse `SingleCov.covered! file: 'target_file.rb'` to set covered file location."
         elsif !File.exist?("#{root}/#{file}")
@@ -277,21 +287,39 @@ module SingleCov
       file
     end
 
-    def warn_about_bad_coverage(file, expected_uncovered, uncovered_lines)
-      details = "(#{uncovered_lines.size} current vs #{expected_uncovered} configured)"
-      if expected_uncovered > uncovered_lines.size
+    def bad_coverage_error(file, expected_uncovered, uncovered)
+      details = "(#{uncovered.size} current vs #{expected_uncovered} configured)"
+      if expected_uncovered > uncovered.size
         if running_single_file?
-          "#{file} has less uncovered lines #{details}, decrement configured uncovered?"
+          warning "#{file} has less uncovered lines #{details}, decrement configured uncovered"
         end
       else
         [
           "#{file} new uncovered lines introduced #{details}",
           red("Lines missing coverage:"),
-          *uncovered_lines
-        ].join("\n")
+          *uncovered.map do |line_start, char_start, line_end, char_end|
+            if char_start # branch coverage
+              if line_start == line_end
+                "#{file}:#{line_start}:#{char_start}-#{char_end}"
+              else # possibly unreachable since branches always seem to be on the same line
+                "#{file}:#{line_start}:#{char_start}-#{line_end}:#{char_end}"
+              end
+            else
+              "#{file}:#{line_start}"
+            end
+          end
+        ]
       end
     end
 
+    def warning(msg)
+      "#{msg}?"
+    end
+
+    def warning?(msg)
+      msg.end_with?("?")
+    end
+
     def red(text)
       if $stdin.tty?
         "\e[31m#{text}\e[0m"
@@ -300,17 +328,17 @@ module SingleCov
       end
     end
 
-    def warn_about_no_coverage(file)
+    def no_coverage_error(file)
       if $LOADED_FEATURES.include?("#{root}/#{file}")
         # we cannot enforce $LOADED_FEATURES during covered! since it would fail when multiple files are loaded
-        "#{file} was expected to be covered, but was already loaded before tests started, which makes it uncoverable."
+        "#{file} was expected to be covered, but was already loaded before coverage started, which makes it uncoverable."
       else
-        "#{file} was expected to be covered, but never loaded."
+        "#{file} was expected to be covered, but was never loaded."
       end
     end
 
-    def file_under_test(file)
-      file = file.dup
+    def guess_covered_file(test)
+      file = test.dup
 
       # remove caller junk to get nice error messages when something fails
       file.sub!(/\.rb\b.*/, '.rb')
@@ -328,7 +356,7 @@ module SingleCov
       end
 
       # rails things live in app
-      file_part[0...0] = if file_part =~ /^(?:#{APP_FOLDERS.map { |f| Regexp.escape(f) }.join('|')})\//
+      file_part[0...0] = if file_part =~ /^(?:#{RAILS_APP_FOLDERS.map { |f| Regexp.escape(f) }.join('|')})\//
         "app/"
       elsif file_part.start_with?("lib/") # don't add lib twice
         ""
@@ -337,8 +365,8 @@ module SingleCov
       end
 
       # remove test extension
-      unless file_part.sub!(/_(?:test|spec)\.rb\b.*/, '.rb')
-        raise "Unable to remove test extension from #{file} ... _test.rb and _spec.rb are supported"
+      if !file_part.sub!(/_(?:test|spec)\.rb\b.*/, '.rb') && !file_part.sub!(/\/test_/, "/")
+        raise "Unable to remove test extension from #{file} ... /test_, _test.rb and _spec.rb are supported"
       end
 
       # put back the subfolder
@@ -352,5 +380,27 @@ module SingleCov
     def root
       @root ||= (defined?(Bundler) && Bundler.root.to_s.sub(/\/gemfiles$/, '')) || Dir.pwd
     end
+
+    def generate_report(results)
+      return unless report = coverage_report
+
+      # not a hard dependency for the whole library
+      require "json"
+      require "fileutils"
+
+      used = COVERAGES.map { |f, _| "#{root}/#{f}" }
+      covered = results.select { |k, _| used.include?(k) }
+
+      if coverage_report_lines
+        covered = covered.transform_values { |v| v.is_a?(Hash) ? v.fetch(:lines) : v }
+      end
+
+      # chose "Minitest" because it is what simplecov uses for reports and "Unit Tests" makes sonarqube break
+      data = JSON.pretty_generate(
+        "Minitest" => { "coverage" => covered, "timestamp" => Time.now.to_i }
+      )
+      FileUtils.mkdir_p(File.dirname(report))
+      File.write report, data
+    end
   end
 end

data/lib/single_cov/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SingleCov
-  VERSION = "1.3.0"
+  VERSION = "1.6.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: single_cov
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Michael Grosser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-14 00:00:00.000000000 Z
+date: 2020-11-07 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: michael@grosser.it
@@ -31,15 +31,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.3
 signing_key: 
 specification_version: 4
 summary: Actionable code coverage.