simplecov 0.17.1 → 0.21.2

data/lib/simplecov/filter.rb

@@ -14,11 +14,12 @@ module SimpleCov
   #
   class Filter
     attr_reader :filter_argument
+
     def initialize(filter_argument)
       @filter_argument = filter_argument
     end
 
-    def matches?(_)
+    def matches?(_source_file)
       raise "The base filter class is not intended for direct use"
     end
 
@@ -29,17 +30,19 @@ module SimpleCov
 
     def self.build_filter(filter_argument)
       return filter_argument if filter_argument.is_a?(SimpleCov::Filter)
+
       class_for_argument(filter_argument).new(filter_argument)
     end
 
     def self.class_for_argument(filter_argument)
-      if filter_argument.is_a?(String)
+      case filter_argument
+      when String
         SimpleCov::StringFilter
-      elsif filter_argument.is_a?(Regexp)
+      when Regexp
         SimpleCov::RegexFilter
-      elsif filter_argument.is_a?(Array)
+      when Array
         SimpleCov::ArrayFilter
-      elsif filter_argument.is_a?(Proc)
+      when Proc
         SimpleCov::BlockFilter
       else
         raise ArgumentError, "You have provided an unrecognized filter type"
@@ -49,7 +52,7 @@ module SimpleCov
 
   class StringFilter < SimpleCov::Filter
     # Returns true when the given source file's filename matches the
-    # string configured when initializing this Filter with StringFilter.new('somestring)
+    # string configured when initializing this Filter with StringFilter.new('somestring')
     def matches?(source_file)
       source_file.project_filename.include?(filter_argument)
     end

data/lib/simplecov/formatter.rb

@@ -6,5 +6,5 @@ module SimpleCov
   end
 end
 
-require "simplecov/formatter/simple_formatter"
-require "simplecov/formatter/multi_formatter"
+require_relative "formatter/simple_formatter"
+require_relative "formatter/multi_formatter"

data/lib/simplecov/formatter/multi_formatter.rb

@@ -6,12 +6,10 @@ module SimpleCov
       module InstanceMethods
         def format(result)
           formatters.map do |formatter|
-            begin
-              formatter.new.format(result)
-            rescue => e
-              STDERR.puts("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
-              nil
-            end
+            formatter.new.format(result)
+          rescue StandardError => e
+            warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
+            nil
           end
         end
       end
@@ -27,7 +25,7 @@ module SimpleCov
 
       def self.[](*args)
         warn "#{Kernel.caller.first}: [DEPRECATION] ::[] is deprecated. Use ::new instead."
-        new(Array([*args]))
+        new(Array(args))
       end
     end
   end

data/lib/simplecov/formatter/simple_formatter.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-#
-# A ridiculously simple formatter for SimpleCov results.
-#
 module SimpleCov
   module Formatter
+    #
+    # A ridiculously simple formatter for SimpleCov results.
+    #
     class SimpleFormatter
       # Takes a SimpleCov::Result and generates a string out of it
       def format(result)
-        output = "".dup
+        output = +""
         result.groups.each do |name, files|
           output << "Group: #{name}\n"
           output << "=" * 40

data/lib/simplecov/last_run.rb

@@ -11,9 +11,11 @@ module SimpleCov
 
       def read
         return nil unless File.exist?(last_run_path)
+
         json = File.read(last_run_path)
         return nil if json.strip.empty?
-        JSON.parse(json)
+
+        JSON.parse(json, symbolize_names: true)
       end
 
       def write(json)

data/lib/simplecov/lines_classifier.rb

@@ -8,23 +8,23 @@ module SimpleCov
     RELEVANT = 0
     NOT_RELEVANT = nil
 
-    WHITESPACE_LINE = /^\s*$/
-    COMMENT_LINE = /^\s*#/
+    WHITESPACE_LINE = /^\s*$/.freeze
+    COMMENT_LINE = /^\s*#/.freeze
     WHITESPACE_OR_COMMENT_LINE = Regexp.union(WHITESPACE_LINE, COMMENT_LINE)
 
     def self.no_cov_line
-      /^(\s*)#(\s*)(\:#{SimpleCov.nocov_token}\:)/o
+      /^(\s*)#(\s*)(:#{SimpleCov.nocov_token}:)/o
     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/no_defaults.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 
 ENV["SIMPLECOV_NO_DEFAULTS"] = "yes, no defaults"
-require "simplecov"
+require_relative "../simplecov"

data/lib/simplecov/process.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Process
+  class << self
+    def fork_with_simplecov(&block)
+      if defined?(SimpleCov) && SimpleCov.running
+        fork_without_simplecov do
+          SimpleCov.at_fork.call(Process.pid)
+          block.call if block_given?
+        end
+      else
+        fork_without_simplecov(&block)
+      end
+    end
+
+    alias fork_without_simplecov fork
+    alias fork fork_with_simplecov
+  end
+end

data/lib/simplecov/profiles.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-#
-# Profiles are SimpleCov configuration procs that can be easily
-# loaded using SimpleCov.start :rails and defined using
-#   SimpleCov.profiles.define :foo do
-#     # SimpleCov configuration here, same as in  SimpleCov.configure
-#   end
-#
 module SimpleCov
+  #
+  # Profiles are SimpleCov configuration procs that can be easily
+  # loaded using SimpleCov.start :rails and defined using
+  #   SimpleCov.profiles.define :foo do
+  #     # SimpleCov configuration here, same as in  SimpleCov.configure
+  #   end
+  #
   class Profiles < Hash
     #
     # Define a SimpleCov profile:
@@ -18,6 +18,7 @@ module SimpleCov
     def define(name, &blk)
       name = name.to_sym
       raise "SimpleCov Profile '#{name}' is already defined" unless self[name].nil?
+
       self[name] = blk
     end
 
@@ -27,6 +28,7 @@ module SimpleCov
     def load(name)
       name = name.to_sym
       raise "Could not find SimpleCov Profile called '#{name}'" unless key?(name)
+
       SimpleCov.configure(&self[name])
     end
   end

data/lib/simplecov/result.rb

@@ -5,7 +5,7 @@ require "forwardable"
 
 module SimpleCov
   #
-  # A simplecov code coverage result, initialized from the Hash Ruby 1.9's built-in coverage
+  # A simplecov code coverage result, initialized from the Hash Ruby's built-in coverage
   # library generates (Coverage.result).
   #
   class Result
@@ -20,15 +20,18 @@ 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
+    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)
-      @original_result = original_result.freeze
-      @files = SimpleCov::FileList.new(original_result.map do |filename, coverage|
-        SimpleCov::SourceFile.new(filename, coverage) if File.file?(filename)
+    def initialize(original_result, command_name: nil, created_at: nil)
+      result = original_result
+      @original_result = result.freeze
+      @command_name = command_name
+      @created_at = created_at
+      @files = SimpleCov::FileList.new(result.map do |filename, coverage|
+        SimpleCov::SourceFile.new(filename, JSON.parse(JSON.dump(coverage))) if File.file?(filename)
       end.compact.sort_by(&:filename))
       filter!
     end
@@ -61,16 +64,19 @@ module SimpleCov
 
     # Returns a hash representation of this Result that can be used for marshalling it into JSON
     def to_hash
-      {command_name => {"coverage" => coverage, "timestamp" => created_at.to_i}}
+      {
+        command_name => {
+          "coverage" => coverage,
+          "timestamp" => created_at.to_i
+        }
+      }
     end
 
     # Loads a SimpleCov::Result#to_hash dump
     def self.from_hash(hash)
-      command_name, data = hash.first
-      result = SimpleCov::Result.new(data["coverage"])
-      result.command_name = command_name
-      result.created_at = Time.at(data["timestamp"])
-      result
+      hash.map do |command_name, data|
+        new(data.fetch("coverage"), command_name: command_name, created_at: Time.at(data["timestamp"]))
+      end
     end
 
   private

data/lib/simplecov/result_adapter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  #
+  # Responsible for adapting the format of the coverage result whether it's default or with statistics
+  #
+  class ResultAdapter
+    attr_reader :result
+
+    def initialize(result)
+      @result = result
+    end
+
+    def self.call(*args)
+      new(*args).adapt
+    end
+
+    def adapt
+      return unless result
+
+      result.each_with_object({}) do |(file_name, cover_statistic), adapted_result|
+        if cover_statistic.is_a?(Array)
+          adapted_result.merge!(file_name => {"lines" => cover_statistic})
+        else
+          adapted_result.merge!(file_name => cover_statistic)
+        end
+      end
+    end
+  end
+end

data/lib/simplecov/result_merger.rb

@@ -2,12 +2,12 @@
 
 require "json"
 
-#
-# Singleton that is responsible for caching, loading and merging
-# SimpleCov::Results into a single result for coverage analysis based
-# upon multiple test suites.
-#
 module SimpleCov
+  #
+  # Singleton that is responsible for caching, loading and merging
+  # SimpleCov::Results into a single result for coverage analysis based
+  # upon multiple test suites.
+  #
   module ResultMerger
     class << self
       # The path to the .resultset.json cache file
@@ -19,79 +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
-              {}
-            end
-          else
-            {}
-          end
-        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
 
-      # 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)
-          data = File.read(resultset_path)
-          return if data.nil? || data.length < 2
-          data
+      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
 
-      # 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 = []
-        resultset.each do |command_name, data|
-          result = SimpleCov::Result.from_hash(command_name => data)
-          # Only add result if the timeout is above the configured threshold
-          if (Time.now - result.created_at) < SimpleCov.merge_timeout
-            results << result
-          end
+      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
+
+      def read_file(path)
+        return unless File.exist?(path)
+
+        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
-        results
+
+        # one file itself _might_ include multiple test runs
+        merge_coverage(*command_plus_coverage)
       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)
-        merged = SimpleCov::RawCoverage.merge_results(*results.map(&:original_result))
-        result = SimpleCov::Result.new(merged)
-        # Specify the command name
-        result.command_name = results.map(&:command_name).sort.join(", ")
-        result
+      def within_merge_timeout?(data)
+        time_since_result_creation(data) < SimpleCov.merge_timeout
+      end
+
+      def time_since_result_creation(data)
+        Time.now - Time.at(data.fetch("timestamp"))
+      end
+
+      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
@@ -114,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