single_cov 1.3.2 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91538588abc7b40a632293cb64315edb846af54cee5b894925716c84b5209423
-  data.tar.gz: 9e2cdd8fb800e72cd957eb80e29a631045aad84075d8c016b5e5ac40cec14829
+  metadata.gz: 3ffed2c03e29890449010148c9492563266983dd70d0f32e7a600692fa6b6a57
+  data.tar.gz: a9395fb02ed4dd4f5490cf4faf8a7c8ef3bd8b084081958c3a86fabb3cbbedcf
 SHA512:
-  metadata.gz: 5daa193ee245aa4a55c49a5f5767286b5f0e1eb6a680f6977efe18eaaffa1867fd7c9fa941d4eafecb141995202a971df490fa4e6814b3662fc788c4509a939e
-  data.tar.gz: fd0bbe8516e1bbf194886d87b38be3a5cf388d6afbecc796dbf6287a39778e81b251a44be890bd43ecc6f39ff8b93f246b272378430a7772b5cd06ee86274101
+  metadata.gz: dddfdd5778b9e3c34b92db87d4288970a6a0bd27154d0c40572bf5fa581f92806214827974b55c2612b19f1298bd1d5827072006fb1d131bf5feb36ccca33513
+  data.tar.gz: 6b82b17a84a018334c140027bab24ef3ac9c08cb0d52973f87d580006d19b0c7cfd3a80b8331b7d487e38af34c8e51f817066170ddee360378587b0b8af03981

data/lib/single_cov/version.rb

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

data/lib/single_cov.rb

@@ -1,81 +1,66 @@
+# 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"
+  MAX_OUTPUT = Integer(ENV["SINGLE_COV_MAX_OUTPUT"] || "40")
+  RAILS_APP_FOLDERS = ["models", "serializers", "helpers", "controllers", "mailers", "views", "jobs", "channels"]
+  UNCOVERED_COMMENT_MARKER = /#.*uncovered/
+  PREFIXES_TO_IGNORE = [] # things to not prefix with lib/ etc
 
   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
-
-          # 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
+      errors = COVERAGES.flat_map do |file, expected_uncovered|
+        next no_coverage_error(file) unless coverage = result["#{root}/#{file}"]
 
-          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
+        uncovered = uncovered(coverage)
+        next if uncovered.size == expected_uncovered
 
-          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("#{root}/#{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
+      if errors.size >= MAX_OUTPUT
+        errors[MAX_OUTPUT..-1] = "... coverage output truncated (use SINGLE_COV_MAX_OUTPUT=999 to expand)"
+      end
+      @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 +68,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 +79,40 @@ module SingleCov
       end
     end
 
-    def setup(framework, root: nil, branches: BRANCH_COVERAGE_SUPPORTED)
+    def assert_full_coverage(tests: default_tests, currently_complete: [], location: nil)
+      location ||= caller(0..1)[1].split(':in').first
+      complete = tests.select { |file| File.read(file) =~ /SingleCov.covered!(?:(?!uncovered).)*(\s*|\s*\#.*)$/ }
+      missing_complete = currently_complete - complete
+      newly_complete = complete - currently_complete
+      errors = []
+
+      if missing_complete.any?
+        errors << <<~MSG
+          The following file(s) were previously marked as having 100% SingleCov test coverage (had no `coverage:` option) but are no longer marked as such.
+          #{missing_complete.join("\n")}
+          Please increase test coverage in these files to maintain 100% coverage and remove `coverage:` usage.
+
+          If this test fails during a file removal, make it pass by removing all references to the removed file's path from the code base.
+        MSG
+      end
+
+      if newly_complete.any?
+        errors << <<~MSG
+          The following files are newly at 100% SingleCov test coverage.
+          Please add the following to #{location} to ensure 100% coverage is maintained moving forward.
+          #{newly_complete.join("\n")}
+        MSG
+      end
+
+      raise errors.join("\n") if errors.any?
+    end
+
+    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 +130,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,32 +145,47 @@ module SingleCov
 
     private
 
+    def uncovered(coverage)
+      return coverage unless coverage.is_a?(Hash) # just lines
+
+      uncovered_lines = indexes(coverage.fetch(:lines), 0).map! { |i| i + 1 }
+      uncovered_branches = uncovered_branches(coverage[:branches] || {})
+      uncovered_branches.reject! { |br| uncovered_lines.include?(br[0]) } # ignore branch when whole line is uncovered
+
+      # combine lines and branches while keeping them sorted
+      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)
-      # {[branch_id] => {[branch_part] => coverage}} --> {branch_part -> sum-of-coverage}
-      sum = Hash.new(0)
+    # {[branch_id] => {[branch_part] => coverage}} --> uncovered location
+    def uncovered_branches(coverage)
+      sum = {}
       coverage.each_value do |branch|
-        branch.each do |k, v|
-          sum[k.slice(2, 4)] += v
+        branch.filter_map do |part, c|
+          location = [part[2], part[3] + 1, part[4], part[5] + 1] # locations can be duplicated
+          type = part[0]
+          info = (sum[location] ||= [0, nil])
+          info[0] += c
+          info[1] = type if type == :else # only else is important to track since it often is not in the code
         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] }
-      found.uniq!
-      found
+      # keep location and type of missing coverage
+      sum.filter_map { |k, v| k + [v[1]] if v[0] == 0 }
     end
 
     def default_tests
@@ -165,10 +196,19 @@ module SingleCov
       Dir["#{root}/#{pattern}"].map! { |f| f.sub("#{root}/", '') }
     end
 
+    def indexes(list, find)
+      list.each_with_index.filter_map { |v, i| i if v == find }
+    end
+
     # 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 +221,7 @@ module SingleCov
       if @branches
         Coverage.start(lines: true, branches: true)
       else
-        Coverage.start
+        Coverage.start(lines: true)
       end
     end
 
@@ -239,7 +279,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 +304,12 @@ 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)
       if file
-        raise "#{file} does not exist and cannot be covered." unless File.exist?("#{root}/#{file}")
+        raise "Use paths relative to project root." if file.start_with?("/")
+        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 +320,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, type|
+            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 + (type ? " # #{type}" : "")
+            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 +361,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')
@@ -333,18 +388,21 @@ module SingleCov
         raise "#{file} includes neither 'test' nor 'spec' folder ... unable to resolve"
       end
 
-      # rails things live in app
-      file_part[0...0] = if file_part =~ /^(?:#{APP_FOLDERS.map { |f| Regexp.escape(f) }.join('|')})\//
-        "app/"
-      elsif file_part.start_with?("lib/") # don't add lib twice
-        ""
-      else # everything else lives in lib
-        "lib/"
-      end
+      without_ignored_prefixes file_part do
+        # rails things live in app
+        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
+            ""
+          else # everything else lives in lib
+            "lib/"
+          end
 
-      # remove test extension
-      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"
+        # remove test extension
+        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
       end
 
       # put back the subfolder
@@ -358,5 +416,40 @@ 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
+
+    # file_part is modified during yield so we have to make sure to also modify in place
+    def without_ignored_prefixes(file_part)
+      folders = file_part.split('/')
+      return yield unless PREFIXES_TO_IGNORE.include?(folders.first)
+
+      prefix = folders.shift
+      file_part.replace folders.join('/')
+
+      yield
+
+      file_part[0...0] = "#{prefix}/"
+    end
   end
 end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: single_cov
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.11.0
 platform: ruby
 authors:
 - Michael Grosser
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-05-09 00:00:00.000000000 Z
+date: 2023-06-03 00:00:00.000000000 Z
 dependencies: []
-description: 
+description:
 email: michael@grosser.it
 executables: []
 extensions: []
@@ -23,7 +23,7 @@ homepage: https://github.com/grosser/single_cov
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -31,16 +31,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: Actionable code coverage.
 test_files: []