simplecov 0.17.0 → 0.18.3

data/lib/simplecov/defaults.rb

@@ -22,11 +22,10 @@ end
 SimpleCov::CommandGuesser.original_run_command = "#{$PROGRAM_NAME} #{ARGV.join(' ')}"
 
 at_exit do
-  # If we are in a different process than called start, don't interfere.
-  next if SimpleCov.pid != Process.pid
+  # Exit hook for Minitest defined in Minitest plugin
+  next if defined?(Minitest)
 
-  SimpleCov.set_exit_exception
-  SimpleCov.run_exit_tasks!
+  SimpleCov.at_exit_behavior
 end
 
 # Autoload config from ~/.simplecov if present
@@ -42,7 +41,7 @@ loop do
     begin
       load filename
     rescue LoadError, StandardError
-      $stderr.puts "Warning: Error occurred while trying to load #{filename}. " \
+      warn "Warning: Error occurred while trying to load #{filename}. " \
         "Error message: #{$!.message}"
     end
     break

data/lib/simplecov/file_list.rb

@@ -1,30 +1,53 @@
 # frozen_string_literal: true
 
-# An array of SimpleCov SourceFile instances with additional collection helper
-# methods for calculating coverage across them etc.
 module SimpleCov
-  class FileList < Array
+  # An array of SimpleCov SourceFile instances with additional collection helper
+  # methods for calculating coverage across them etc.
+  class FileList
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :@files,
+                   # For Enumerable
+                   :each,
+                   # also delegating methods implemented in Enumerable as they have
+                   # custom Array implementations which are presumably better/more
+                   # resource efficient
+                   :size, :map, :count,
+                   # surprisingly not in Enumerable
+                   :empty?, :length,
+                   # still act like we're kinda an array
+                   :to_a, :to_ary
+
+    def initialize(files)
+      @files = files
+    end
+
+    def coverage_statistics
+      @coverage_statistics ||= compute_coverage_statistics
+    end
+
     # Returns the count of lines that have coverage
     def covered_lines
-      return 0.0 if empty?
-      map { |f| f.covered_lines.count }.inject(:+)
+      coverage_statistics[:line]&.covered
     end
 
     # Returns the count of lines that have been missed
     def missed_lines
-      return 0.0 if empty?
-      map { |f| f.missed_lines.count }.inject(:+)
+      coverage_statistics[:line]&.missed
     end
 
     # Returns the count of lines that are not relevant for coverage
     def never_lines
       return 0.0 if empty?
+
       map { |f| f.never_lines.count }.inject(:+)
     end
 
     # Returns the count of skipped lines
     def skipped_lines
       return 0.0 if empty?
+
       map { |f| f.skipped_lines.count }.inject(:+)
     end
 
@@ -36,26 +59,56 @@ module SimpleCov
 
     # Finds the least covered file and returns that file's name
     def least_covered_file
-      sort_by(&:covered_percent).first.filename
+      min_by(&:covered_percent).filename
     end
 
     # Returns the overall amount of relevant lines of code across all files in this list
     def lines_of_code
-      covered_lines + missed_lines
+      coverage_statistics[:line]&.total
     end
 
     # Computes the coverage based upon lines covered and lines missed
     # @return [Float]
     def covered_percent
-      return 100.0 if empty? || lines_of_code.zero?
-      Float(covered_lines * 100.0 / lines_of_code)
+      coverage_statistics[:line]&.percent
     end
 
     # Computes the strength (hits / line) based upon lines covered and lines missed
     # @return [Float]
     def covered_strength
-      return 0.0 if empty? || lines_of_code.zero?
-      Float(map { |f| f.covered_strength * f.lines_of_code }.inject(:+) / lines_of_code)
+      coverage_statistics[:line]&.strength
+    end
+
+    # Return total count of branches in all files
+    def total_branches
+      coverage_statistics[:branch]&.total
+    end
+
+    # Return total count of covered branches
+    def covered_branches
+      coverage_statistics[:branch]&.covered
+    end
+
+    # Return total count of covered branches
+    def missed_branches
+      coverage_statistics[:branch]&.missed
+    end
+
+    def branch_covered_percent
+      coverage_statistics[:branch]&.percent
+    end
+
+  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?
+      end
+
+      coverage_statistics = {line: CoverageStatistics.from(total_coverage_statistics[:line])}
+      coverage_statistics[:branch] = CoverageStatistics.from(total_coverage_statistics[:branch]) if SimpleCov.branch_coverage?
+      coverage_statistics
     end
   end
 end

data/lib/simplecov/filter.rb

@@ -18,7 +18,7 @@ module SimpleCov
       @filter_argument = filter_argument
     end
 
-    def matches?(_)
+    def matches?(_source_file)
       raise "The base filter class is not intended for direct use"
     end
 
@@ -29,6 +29,7 @@ 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
 

data/lib/simplecov/formatter/multi_formatter.rb

@@ -8,8 +8,8 @@ module SimpleCov
           formatters.map do |formatter|
             begin
               formatter.new.format(result)
-            rescue => e
-              STDERR.puts("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
+            rescue StandardError => e
+              warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
               nil
             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,8 +8,8 @@ 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

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,16 @@ 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
     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)
+      result = adapt_result(original_result)
+      @original_result = result.freeze
+      @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,13 +62,20 @@ 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
@@ -75,6 +83,31 @@ 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/colszowka/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.map do |file_path, line_coverage_data|
+        [file_path, {"lines" => line_coverage_data}]
+      end.to_h
+    end
+
     def coverage
       keys = original_result.keys & filenames
       Hash[keys.zip(original_result.values_at(*keys))]

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
@@ -27,7 +27,7 @@ module SimpleCov
           if data
             begin
               JSON.parse(data) || {}
-            rescue
+            rescue StandardError
               {}
             end
           else
@@ -40,8 +40,10 @@ module SimpleCov
       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
         end
       end
@@ -55,19 +57,24 @@ module SimpleCov
         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
+          results << result if (Time.now - result.created_at) < SimpleCov.merge_timeout
         end
         results
       end
 
+      def merge_and_store(*results)
+        result = merge_results(*results)
+        store_result(result) if result
+        result
+      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)
+        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

data/lib/simplecov/simulate_coverage.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  #
+  # Responsible for producing file coverage metrics.
+  #
+  module SimulateCoverage
+  module_function
+
+    #
+    # Simulate normal file coverage report on
+    # ruby 2.5 and return similar hash with lines and branches keys
+    #
+    # Happens when a file wasn't required but still tracked.
+    #
+    # @return [Hash]
+    #
+    def call(absolute_path)
+      lines = File.foreach(absolute_path)
+
+      {
+        "lines" => LinesClassifier.new.classify(lines),
+        # we don't want to parse branches ourselves...
+        # requiring files can have side effects and we don't want to trigger that
+        "branches" => {}
+      }
+    end
+  end
+end