single_cov 1.3.2 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91538588abc7b40a632293cb64315edb846af54cee5b894925716c84b5209423
-  data.tar.gz: 9e2cdd8fb800e72cd957eb80e29a631045aad84075d8c016b5e5ac40cec14829
+  metadata.gz: 9b93f5dd228599154416958a87e4f96ddd97a5477d92b7fc6c43c80ff3d6485f
+  data.tar.gz: ccd0f0c8b95df16fae3c071000b2499cca41bffea096bd84a8d761444335b2c4
 SHA512:
-  metadata.gz: 5daa193ee245aa4a55c49a5f5767286b5f0e1eb6a680f6977efe18eaaffa1867fd7c9fa941d4eafecb141995202a971df490fa4e6814b3662fc788c4509a939e
-  data.tar.gz: fd0bbe8516e1bbf194886d87b38be3a5cf388d6afbecc796dbf6287a39778e81b251a44be890bd43ecc6f39ff8b93f246b272378430a7772b5cd06ee86274101
+  metadata.gz: 827b9ed7610e88def4654d18d8e2d4fa01c1f6c296a260c64ef8f4a722d1a478e195fefbfaf45afbeb8d6710a644f071f48e117cb927daf2d5bb0b42decd14e9
+  data.tar.gz: 3a21bb814833a4a73b5303f4b354218014f0a7b5e05eac89863b3508f7b6b488a06177577ce383d6a706847716dbc6706b37583d499deafee1a516a5d8a1e5c2

data/lib/single_cov/version.rb

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

data/lib/single_cov.rb

@@ -1,81 +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_lines = line_coverage.each_with_index.map { |c, i| i + 1 if c == 0 }.compact
-
-          branch_coverage = (coverage.is_a?(Hash) && coverage[:branches])
-          uncovered_branches = (branch_coverage ? uncovered_branches(branch_coverage, uncovered_lines) : [])
-
-          uncovered = uncovered_lines.concat uncovered_branches
-          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
-          next if uncovered.size == expected_uncovered
+      errors = COVERAGES.flat_map do |file, expected_uncovered|
+        next no_coverage_error(file) unless coverage = result["#{root}/#{file}"]
 
-          # branches are unsorted and added to the end, only sort when displayed
-          if branch_coverage
-            uncovered.sort_by! { |line_start, char_start, _, _| [line_start, char_start || 0] }
-          end
+        uncovered = uncovered(coverage)
+        next if uncovered.size == expected_uncovered
 
-          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
-
-          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
+      @error_logger.puts 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")
@@ -83,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
 
@@ -94,13 +76,12 @@ module SingleCov
       end
     end
 
-    def setup(framework, root: nil, branches: BRANCH_COVERAGE_SUPPORTED)
+    def setup(framework, root: nil, branches: true, err: $stderr)
+      @error_logger = err
+
       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
@@ -118,7 +99,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
 
@@ -129,19 +114,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|
@@ -150,9 +154,8 @@ module SingleCov
         end
       end
 
-      # show missing coverage
-      sum.select! { |k, v| v.zero? && !uncovered_lines.include?(k[0]) }
-      found = sum.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
@@ -168,7 +171,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
@@ -181,7 +189,7 @@ module SingleCov
       if @branches
         Coverage.start(lines: true, branches: true)
       else
-        Coverage.start
+        Coverage.start(lines: true)
       end
     end
 
@@ -239,7 +247,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
@@ -264,15 +272,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}")
@@ -283,21 +289,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"
@@ -306,17 +330,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')
@@ -334,7 +358,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
         ""
@@ -358,5 +382,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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: single_cov
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.7.0
 platform: ruby
 authors:
 - Michael Grosser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-09 00:00:00.000000000 Z
+date: 2022-01-13 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.6
 signing_key: 
 specification_version: 4
 summary: Actionable code coverage.