simplecov 0.6.4 → 0.17.1

data/lib/simplecov/load_global_config.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "etc"
+home_dir = (ENV["HOME"] && File.expand_path("~")) || Etc.getpwuid.dir || (ENV["USER"] && File.expand_path("~#{ENV['USER']}"))
+if home_dir
+  global_config_path = File.join(home_dir, ".simplecov")
+  load global_config_path if File.exist?(global_config_path)
+end

data/lib/simplecov/no_defaults.rb

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

data/lib/simplecov/profiles.rb

@@ -0,0 +1,33 @@
+# 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
+  class Profiles < Hash
+    #
+    # Define a SimpleCov profile:
+    #   SimpleCov.profiles.define 'rails' do
+    #     # Same as SimpleCov.configure do .. here
+    #   end
+    #
+    def define(name, &blk)
+      name = name.to_sym
+      raise "SimpleCov Profile '#{name}' is already defined" unless self[name].nil?
+      self[name] = blk
+    end
+
+    #
+    # Applies the profile of given name on SimpleCov.configure
+    #
+    def load(name)
+      name = name.to_sym
+      raise "Could not find SimpleCov Profile called '#{name}'" unless key?(name)
+      SimpleCov.configure(&self[name])
+    end
+  end
+end

data/lib/simplecov/profiles/bundler_filter.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "bundler_filter" do
+  add_filter "/vendor/bundle/"
+end

data/lib/simplecov/profiles/hidden_filter.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "hidden_filter" do
+  add_filter %r{^/\..*}
+end

data/lib/simplecov/profiles/rails.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "rails" do
+  load_profile "test_frameworks"
+
+  add_filter %r{^/config/}
+  add_filter %r{^/db/}
+
+  add_group "Controllers", "app/controllers"
+  add_group "Channels", "app/channels"
+  add_group "Models", "app/models"
+  add_group "Mailers", "app/mailers"
+  add_group "Helpers", "app/helpers"
+  add_group "Jobs", %w[app/jobs app/workers]
+  add_group "Libraries", "lib/"
+
+  track_files "{app,lib}/**/*.rb"
+end

data/lib/simplecov/profiles/root_filter.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "root_filter" do
+  # Exclude all files outside of simplecov root
+  root_filter = nil
+  add_filter do |src|
+    root_filter ||= /\A#{Regexp.escape(SimpleCov.root + File::SEPARATOR)}/io
+    src.filename !~ root_filter
+  end
+end

data/lib/simplecov/profiles/test_frameworks.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+SimpleCov.profiles.define "test_frameworks" do
+  add_filter "/test/"
+  add_filter "/features/"
+  add_filter "/spec/"
+  add_filter "/autotest/"
+end

data/lib/simplecov/railtie.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module SimpleCov
   class Railtie < ::Rails::Railtie
     rake_tasks do
-      load 'simplecov/railties/tasks.rake'
+      load "simplecov/railties/tasks.rake"
     end
   end
 end

data/lib/simplecov/railties/tasks.rake

@@ -1,11 +1,13 @@
-require 'rake/testtask'
+# frozen_string_literal: true
+
+require "rake/testtask"
 Rake::TestTask.new do |t|
-  t.name = 'simplecov'
+  t.name = "simplecov"
   t.loader = :direct # uses require() which skips PWD in Ruby 1.9
-  t.libs.push 'test', 'spec', Dir.pwd
-  t.test_files = FileList['{test,spec}/**/*_{test,spec}.rb']
-  t.ruby_opts.push '-r', 'simplecov', '-e', 'SimpleCov.start(:rails)'.inspect
+  t.libs.push "test", "spec", Dir.pwd
+  t.test_files = FileList["{test,spec}/**/*_{test,spec}.rb"]
+  t.ruby_opts.push "-r", "simplecov", "-e", "SimpleCov.start(:rails)".inspect
 end
 
-require 'rake/clean'
-CLOBBER.include 'coverage'
+require "rake/clean"
+CLOBBER.include "coverage"

data/lib/simplecov/raw_coverage.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  module RawCoverage
+  module_function
+
+    # Merges multiple Coverage.result hashes
+    def merge_results(*results)
+      results.reduce({}) do |result, merged|
+        merge_resultsets(result, merged)
+      end
+    end
+
+    # Merges two Coverage.result hashes
+    def merge_resultsets(result1, result2)
+      (result1.keys | result2.keys).each_with_object({}) do |filename, merged|
+        file1 = result1[filename]
+        file2 = result2[filename]
+        merged[filename] = merge_file_coverage(file1, file2)
+      end
+    end
+
+    def merge_file_coverage(file1, file2)
+      return (file1 || file2).dup unless file1 && file2
+
+      file1.map.with_index do |count1, index|
+        count2 = file2[index]
+        merge_line_coverage(count1, count2)
+      end
+    end
+
+    def merge_line_coverage(count1, count2)
+      sum = count1.to_i + count2.to_i
+      if sum.zero? && (count1.nil? || count2.nil?)
+        nil
+      else
+        sum
+      end
+    end
+  end
+end

data/lib/simplecov/result.rb

@@ -1,4 +1,7 @@
-require 'digest/sha1'
+# frozen_string_literal: true
+
+require "digest/sha1"
+require "forwardable"
 
 module SimpleCov
   #
@@ -6,16 +9,20 @@ module SimpleCov
   # library generates (Coverage.result).
   #
   class Result
+    extend Forwardable
     # Returns the original Coverage.result used for this instance of SimpleCov::Result
     attr_reader :original_result
     # Returns all files that are applicable to this result (sans filters!) as instances of SimpleCov::SourceFile. Aliased as :source_files
     attr_reader :files
-    alias_method :source_files, :files
+    alias source_files files
     # Explicitly set the Time this result has been created
     attr_writer :created_at
     # 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_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)
@@ -36,56 +43,6 @@ module SimpleCov
       @groups ||= SimpleCov.grouped(files)
     end
 
-    # The overall percentual coverage for this result
-    def covered_percent
-      # Make sure that weird rounding error from #15, #23 and #24 does not occur again!
-      total_lines.zero? ? 0 : 100.0 * covered_lines / total_lines
-    end
-
-    # The multiple of coverage for this result
-    def covered_strength
-      return 0 if total_lines.zero?
-      return @covered_strength if @covered_strength
-      m = 0
-      @files.each do |file|
-        original_result[file.filename].each do |line_result|
-          if line_result
-            m += line_result
-          end
-        end
-      end
-      @covered_strength = m.to_f / total_lines
-    end
-
-    # Returns the count of lines that are covered
-    def covered_lines
-      return @covered_lines if defined? @covered_lines
-      @covered_lines = 0
-      @files.each do |file|
-        original_result[file.filename].each do |line_result|
-          @covered_lines += 1 if line_result and line_result > 0
-        end
-      end
-      @covered_lines
-    end
-
-    # Returns the count of missed lines
-    def missed_lines
-      return @missed_lines if defined? @missed_lines
-      @missed_lines = 0
-      @files.each do |file|
-        original_result[file.filename].each do |line_result|
-          @missed_lines += 1 if line_result == 0
-        end
-      end
-      @missed_lines
-    end
-
-    # Total count of relevant lines (covered + missed)
-    def total_lines
-      @total_lines ||= (covered_lines + missed_lines)
-    end
-
     # Applies the configured SimpleCov.formatter on this result
     def format!
       SimpleCov.formatter.new.format(self)
@@ -102,9 +59,9 @@ module SimpleCov
       @command_name ||= SimpleCov.command_name
     end
 
-    # Returns a hash representation of this Result that can be used for marshalling it into YAML
+    # Returns a hash representation of this Result that can be used for marshalling it into JSON
     def to_hash
-      {command_name => {"coverage" => original_result.reject {|filename, result| !filenames.include?(filename) }, "timestamp" => created_at.to_i}}
+      {command_name => {"coverage" => coverage, "timestamp" => created_at.to_i}}
     end
 
     # Loads a SimpleCov::Result#to_hash dump
@@ -116,7 +73,12 @@ module SimpleCov
       result
     end
 
-    private
+  private
+
+    def coverage
+      keys = original_result.keys & filenames
+      Hash[keys.zip(original_result.values_at(*keys))]
+    end
 
     # Applies all configured SimpleCov filters on this result's source files
     def filter!

data/lib/simplecov/result_merger.rb

@@ -1,90 +1,123 @@
-require 'multi_json'
+# frozen_string_literal: true
+
+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::ResultMerger
-  class << self
-    # The path to the resultset.yml cache file
-    def resultset_path
-      File.join(SimpleCov.coverage_path, '.resultset.json')
-    end
+module SimpleCov
+  module ResultMerger
+    class << self
+      # The path to the .resultset.json cache file
+      def resultset_path
+        File.join(SimpleCov.coverage_path, ".resultset.json")
+      end
 
-    # Loads the cached resultset from YAML and returns it as a Hash
-    def resultset
-      if stored_data
-        # Detect and use available MultiJson API - it changed in v1.3
-        if MultiJson.respond_to?(:adapter)
-          MultiJson.load(stored_data)
-        else
-          MultiJson.decode(stored_data)
+      def resultset_writelock
+        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
-      else
-        {}
       end
-    end
 
-    # Returns the contents of the resultset cache as a string or if the file is missing or empty nil
-    def stored_data
-      if File.exist?(resultset_path) and stored_data = File.read(resultset_path) and stored_data.length >= 2
-        stored_data
-      else
-        nil
+      # 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
+        end
       end
-    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
+      # 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
         end
+        results
       end
-      results
-    end
 
-    #
-    # Gets all SimpleCov::Results from cache, 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
-      merged = {}
-      results.each do |result|
-        merged = result.original_result.merge_resultset(merged)
+      # 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
       end
-      result = SimpleCov::Result.new(merged)
-      # Specify the command name
-      result.command_name = results.map(&:command_name).sort.join(", ")
-      result
-    end
 
-    # Saves the given SimpleCov::Result in the resultset cache
-    def store_result(result)
-      new_set = resultset
-      command_name, data = result.to_hash.first
-      new_set[command_name] = data
-      File.open(resultset_path, "w+") do |f|
-        if defined? ::JSON
-          f.puts JSON.pretty_generate(new_set)
-        else
-          # Detect and use available MultiJson API - it changed in v1.3
-          if MultiJson.respond_to?(:adapter)
-            f.puts MultiJson.dump(new_set)
-          else
-            f.puts MultiJson.encode(new_set)
+      #
+      # Gets all SimpleCov::Results from cache, 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)
+      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
+          command_name, data = result.to_hash.first
+          new_set[command_name] = data
+          File.open(resultset_path, "w+") do |f_|
+            f_.puts JSON.pretty_generate(new_set)
           end
         end
+        true
+      end
+
+      # Ensure only one process is reading or writing the resultset at any
+      # given time
+      def synchronize_resultset
+        # make it reentrant
+        return yield if defined?(@resultset_locked) && @resultset_locked
+
+        begin
+          @resultset_locked = true
+          File.open(resultset_writelock, "w+") do |f|
+            f.flock(File::LOCK_EX)
+            yield
+          end
+        ensure
+          @resultset_locked = false
+        end
+      end
+
+      # Clear out the previously cached .resultset
+      def clear_resultset
+        @resultset = nil
       end
-      true
     end
   end
 end