simplecov 0.19.0 → 0.21.2

data/lib/simplecov/exit_codes/minimum_coverage_by_file_check.rb

@@ -9,16 +9,18 @@ module SimpleCov
       end
 
       def failing?
-        covered_percentages.any? { |p| p < minimum_coverage_by_file }
+        minimum_violations.any?
       end
 
       def report
-        $stderr.printf(
-          "File (%<file>s) is only (%<least_covered_percentage>.2f%%) covered. This is below the expected minimum coverage per file of (%<min_coverage>.2f%%).\n",
-          file: result.least_covered_file,
-          least_covered_percentage: covered_percentages.min,
-          min_coverage: minimum_coverage_by_file
-        )
+        minimum_violations.each do |violation|
+          $stderr.printf(
+            "%<criterion>s coverage by file (%<covered>.2f%%) is below the expected minimum coverage (%<minimum_coverage>.2f%%).\n",
+            covered: SimpleCov.round_coverage(violation.fetch(:actual)),
+            minimum_coverage: violation.fetch(:minimum_expected),
+            criterion: violation.fetch(:criterion).capitalize
+          )
+        end
       end
 
       def exit_code
@@ -29,9 +31,23 @@ module SimpleCov
 
       attr_reader :result, :minimum_coverage_by_file
 
-      def covered_percentages
-        @covered_percentages ||=
-          result.covered_percentages.map { |percentage| SimpleCov.round_coverage(percentage) }
+      def minimum_violations
+        @minimum_violations ||=
+          compute_minimum_coverage_data.select do |achieved|
+            achieved.fetch(:actual) < achieved.fetch(:minimum_expected)
+          end
+      end
+
+      def compute_minimum_coverage_data
+        minimum_coverage_by_file.flat_map do |criterion, expected_percent|
+          result.coverage_statistics_by_file.fetch(criterion).map do |actual_coverage|
+            {
+              criterion: criterion,
+              minimum_expected: expected_percent,
+              actual: SimpleCov.round_coverage(actual_coverage.percent)
+            }
+          end
+        end
       end
     end
   end

data/lib/simplecov/file_list.rb

@@ -27,6 +27,10 @@ module SimpleCov
       @coverage_statistics ||= compute_coverage_statistics
     end
 
+    def coverage_statistics_by_file
+      @coverage_statistics_by_file ||= compute_coverage_statistics_by_file
+    end
+
     # Returns the count of lines that have coverage
     def covered_lines
       coverage_statistics[:line]&.covered
@@ -100,14 +104,16 @@ module SimpleCov
 
   private
 
-    def compute_coverage_statistics
-      total_coverage_statistics = @files.each_with_object(line: [], branch: []) do |file, together|
-        together[:line] << file.coverage_statistics[:line]
-        together[:branch] << file.coverage_statistics[:branch] if SimpleCov.branch_coverage?
+    def compute_coverage_statistics_by_file
+      @files.each_with_object(line: [], branch: []) do |file, together|
+        together[:line] << file.coverage_statistics.fetch(:line)
+        together[:branch] << file.coverage_statistics.fetch(:branch) if SimpleCov.branch_coverage?
       end
+    end
 
-      coverage_statistics = {line: CoverageStatistics.from(total_coverage_statistics[:line])}
-      coverage_statistics[:branch] = CoverageStatistics.from(total_coverage_statistics[:branch]) if SimpleCov.branch_coverage?
+    def compute_coverage_statistics
+      coverage_statistics = {line: CoverageStatistics.from(coverage_statistics_by_file[:line])}
+      coverage_statistics[:branch] = CoverageStatistics.from(coverage_statistics_by_file[:branch]) if SimpleCov.branch_coverage?
       coverage_statistics
     end
   end

data/lib/simplecov/lines_classifier.rb

@@ -17,14 +17,14 @@ module SimpleCov
     end
 
     def self.no_cov_line?(line)
-      line =~ no_cov_line
+      no_cov_line.match?(line)
     rescue ArgumentError
       # E.g., line contains an invalid byte sequence in UTF-8
       false
     end
 
     def self.whitespace_line?(line)
-      line =~ WHITESPACE_OR_COMMENT_LINE
+      WHITESPACE_OR_COMMENT_LINE.match?(line)
     rescue ArgumentError
       # E.g., line contains an invalid byte sequence in UTF-8
       false

data/lib/simplecov/result.rb

@@ -20,13 +20,13 @@ module SimpleCov
     # Explicitly set the command name that was used for this coverage result. Defaults to SimpleCov.command_name
     attr_writer :command_name
 
-    def_delegators :files, :covered_percent, :covered_percentages, :least_covered_file, :covered_strength, :covered_lines, :missed_lines, :total_branches, :covered_branches, :missed_branches, :coverage_statistics
+    def_delegators :files, :covered_percent, :covered_percentages, :least_covered_file, :covered_strength, :covered_lines, :missed_lines, :total_branches, :covered_branches, :missed_branches, :coverage_statistics, :coverage_statistics_by_file
     def_delegator :files, :lines_of_code, :total_lines
 
     # Initialize a new SimpleCov::Result from given Coverage.result (a Hash of filenames each containing an array of
     # coverage data)
     def initialize(original_result, command_name: nil, created_at: nil)
-      result = adapt_result(original_result)
+      result = original_result
       @original_result = result.freeze
       @command_name = command_name
       @created_at = created_at
@@ -72,10 +72,6 @@ module SimpleCov
       }
     end
 
-    def time_since_creation
-      Time.now - created_at
-    end
-
     # Loads a SimpleCov::Result#to_hash dump
     def self.from_hash(hash)
       hash.map do |command_name, data|
@@ -85,31 +81,6 @@ module SimpleCov
 
   private
 
-    # We changed the format of the raw result data in simplecov, as people are likely
-    # to have "old" resultsets lying around (but not too old so that they're still
-    # considered we can adapt them).
-    # See https://github.com/simplecov-ruby/simplecov/pull/824#issuecomment-576049747
-    def adapt_result(result)
-      if pre_simplecov_0_18_result?(result)
-        adapt_pre_simplecov_0_18_result(result)
-      else
-        result
-      end
-    end
-
-    # pre 0.18 coverage data pointed from file directly to an array of line coverage
-    def pre_simplecov_0_18_result?(result)
-      _key, data = result.first
-
-      data.is_a?(Array)
-    end
-
-    def adapt_pre_simplecov_0_18_result(result)
-      result.transform_values do |line_coverage_data|
-        {"lines" => line_coverage_data}
-      end
-    end
-
     def coverage
       keys = original_result.keys & filenames
       Hash[keys.zip(original_result.values_at(*keys))]

data/lib/simplecov/result_merger.rb

@@ -19,81 +19,130 @@ module SimpleCov
         File.join(SimpleCov.coverage_path, ".resultset.json.lock")
       end
 
-      # Loads the cached resultset from JSON and returns it as a Hash,
-      # caching it for subsequent accesses.
-      def resultset
-        @resultset ||= begin
-          data = stored_data
-          if data
-            begin
-              JSON.parse(data) || {}
-            rescue StandardError
-              {}
-            end
-          else
-            {}
-          end
+      def merge_and_store(*file_paths, ignore_timeout: false)
+        result = merge_results(*file_paths, ignore_timeout: ignore_timeout)
+        store_result(result) if result
+        result
+      end
+
+      def merge_results(*file_paths, ignore_timeout: false)
+        # It is intentional here that files are only read in and parsed one at a time.
+        #
+        # In big CI setups you might deal with 100s of CI jobs and each one producing Megabytes
+        # of data. Reading them all in easily produces Gigabytes of memory consumption which
+        # we want to avoid.
+        #
+        # For similar reasons a SimpleCov::Result is only created in the end as that'd create
+        # even more data especially when it also reads in all source files.
+        initial_memo = valid_results(file_paths.shift, ignore_timeout: ignore_timeout)
+
+        command_names, coverage = file_paths.reduce(initial_memo) do |memo, file_path|
+          merge_coverage(memo, valid_results(file_path, ignore_timeout: ignore_timeout))
         end
+
+        create_result(command_names, coverage)
       end
 
-      # Returns the contents of the resultset cache as a string or if the file is missing or empty nil
-      def stored_data
-        synchronize_resultset do
-          return unless File.exist?(resultset_path)
+      def valid_results(file_path, ignore_timeout: false)
+        results = parse_file(file_path)
+        merge_valid_results(results, ignore_timeout: ignore_timeout)
+      end
+
+      def parse_file(path)
+        data = read_file(path)
+        parse_json(data)
+      end
 
-          data = File.read(resultset_path)
-          return if data.nil? || data.length < 2
+      def read_file(path)
+        return unless File.exist?(path)
 
-          data
+        data = File.read(path)
+        return if data.nil? || data.length < 2
+
+        data
+      end
+
+      def parse_json(content)
+        return {} unless content
+
+        JSON.parse(content) || {}
+      rescue StandardError
+        warn "[SimpleCov]: Warning! Parsing JSON content of resultset file failed"
+        {}
+      end
+
+      def merge_valid_results(results, ignore_timeout: false)
+        results = results.select { |_command_name, data| within_merge_timeout?(data) } unless ignore_timeout
+
+        command_plus_coverage = results.map do |command_name, data|
+          [[command_name], adapt_result(data.fetch("coverage"))]
         end
+
+        # one file itself _might_ include multiple test runs
+        merge_coverage(*command_plus_coverage)
       end
 
-      # Gets the resultset hash and re-creates all included instances
-      # of SimpleCov::Result from that.
-      # All results that are above the SimpleCov.merge_timeout will be
-      # dropped. Returns an array of SimpleCov::Result items.
-      def results
-        results = Result.from_hash(resultset)
-        results.select { |result| result.time_since_creation < SimpleCov.merge_timeout }
+      def within_merge_timeout?(data)
+        time_since_result_creation(data) < SimpleCov.merge_timeout
       end
 
-      def merge_and_store(*results)
-        result = merge_results(*results)
-        store_result(result) if result
-        result
+      def time_since_result_creation(data)
+        Time.now - Time.at(data.fetch("timestamp"))
       end
 
-      # Merge two or more SimpleCov::Results into a new one with merged
-      # coverage data and the command_name for the result consisting of a join
-      # on all source result's names
-      def merge_results(*results)
-        parsed_results = JSON.parse(JSON.dump(results.map(&:original_result)))
-        combined_result = SimpleCov::Combine::ResultsCombiner.combine(*parsed_results)
-        result = SimpleCov::Result.new(combined_result)
-        # Specify the command name
-        result.command_name = results.map(&:command_name).sort.join(", ")
-        result
+      def create_result(command_names, coverage)
+        return nil unless coverage
+
+        command_name = command_names.reject(&:empty?).sort.join(", ")
+        SimpleCov::Result.new(coverage, command_name: command_name)
+      end
+
+      def merge_coverage(*results)
+        return [[""], nil] if results.empty?
+        return results.first if results.size == 1
+
+        results.reduce do |(memo_command, memo_coverage), (command, coverage)|
+          # timestamp is dropped here, which is intentional (we merge it, it gets a new time stamp as of now)
+          merged_coverage = Combine.combine(Combine::ResultsCombiner, memo_coverage, coverage)
+          merged_command = memo_command + command
+
+          [merged_command, merged_coverage]
+        end
       end
 
       #
-      # Gets all SimpleCov::Results from cache, merges them and produces a new
+      # Gets all SimpleCov::Results stored in resultset, merges them and produces a new
       # SimpleCov::Result with merged coverage data and the command_name
       # for the result consisting of a join on all source result's names
-      #
       def merged_result
-        merge_results(*results)
+        # conceptually this is just doing `merge_results(resultset_path)`
+        # it's more involved to make syre `synchronize_resultset` is only used around reading
+        resultset_hash = read_resultset
+        command_names, coverage = merge_valid_results(resultset_hash)
+
+        create_result(command_names, coverage)
+      end
+
+      def read_resultset
+        resultset_content =
+          synchronize_resultset do
+            read_file(resultset_path)
+          end
+
+        parse_json(resultset_content)
       end
 
       # Saves the given SimpleCov::Result in the resultset cache
       def store_result(result)
         synchronize_resultset do
           # Ensure we have the latest, in case it was already cached
-          clear_resultset
-          new_set = resultset
+          new_resultset = read_resultset
+
+          # A single result only ever has one command_name, see `SimpleCov::Result#to_hash`
           command_name, data = result.to_hash.first
-          new_set[command_name] = data
+          new_resultset[command_name] = data
           File.open(resultset_path, "w+") do |f_|
-            f_.puts JSON.pretty_generate(new_set)
+            f_.puts JSON.pretty_generate(new_resultset)
           end
         end
         true
@@ -116,9 +165,29 @@ module SimpleCov
         end
       end
 
-      # Clear out the previously cached .resultset
-      def clear_resultset
-        @resultset = nil
+      # We changed the format of the raw result data in simplecov, as people are likely
+      # to have "old" resultsets lying around (but not too old so that they're still
+      # considered we can adapt them).
+      # See https://github.com/simplecov-ruby/simplecov/pull/824#issuecomment-576049747
+      def adapt_result(result)
+        if pre_simplecov_0_18_result?(result)
+          adapt_pre_simplecov_0_18_result(result)
+        else
+          result
+        end
+      end
+
+      # pre 0.18 coverage data pointed from file directly to an array of line coverage
+      def pre_simplecov_0_18_result?(result)
+        _key, data = result.first
+
+        data.is_a?(Array)
+      end
+
+      def adapt_pre_simplecov_0_18_result(result)
+        result.transform_values do |line_coverage_data|
+          {"lines" => line_coverage_data}
+        end
       end
     end
   end

data/lib/simplecov/source_file/line.rb

@@ -56,7 +56,7 @@ module SimpleCov
       # Returns true if this line was skipped, false otherwise. Lines are skipped if they are wrapped with
       # # :nocov: comment lines.
       def skipped?
-        !!skipped
+        skipped
       end
 
       # The status of this line - either covered, missed, skipped or never. Useful i.e. for direct use

data/lib/simplecov/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleCov
-  VERSION = "0.19.0"
+  VERSION = "0.21.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simplecov
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.21.2
 platform: ruby
 authors:
 - Christoph Olszowka
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-16 00:00:00.000000000 Z
+date: 2021-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docile
@@ -39,6 +39,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: simplecov_json_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 description: Code coverage for Ruby with a powerful configuration library and automatic
   merging of coverage across test suites
 email:
@@ -49,9 +63,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- CODE_OF_CONDUCT.md
-- CONTRIBUTING.md
-- ISSUE_TEMPLATE.md
 - LICENSE
 - README.md
 - doc/alternate-formatters.md
@@ -67,6 +78,7 @@ files:
 - lib/simplecov/command_guesser.rb
 - lib/simplecov/configuration.rb
 - lib/simplecov/coverage_statistics.rb
+- lib/simplecov/default_formatter.rb
 - lib/simplecov/defaults.rb
 - lib/simplecov/exit_codes.rb
 - lib/simplecov/exit_codes/exit_code_handling.rb
@@ -104,9 +116,9 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/simplecov-ruby/simplecov/issues
   changelog_uri: https://github.com/simplecov-ruby/simplecov/blob/main/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/simplecov/0.19.0
+  documentation_uri: https://www.rubydoc.info/gems/simplecov/0.21.2
   mailing_list_uri: https://groups.google.com/forum/#!forum/simplecov
-  source_code_uri: https://github.com/simplecov-ruby/simplecov/tree/v0.19.0
+  source_code_uri: https://github.com/simplecov-ruby/simplecov/tree/v0.21.2
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -122,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: Code coverage for Ruby