simplecov 0.13.0 → 0.17.1

data/lib/simplecov/exit_codes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SimpleCov
   module ExitCodes
     SUCCESS = 0

data/lib/simplecov/file_list.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # An array of SimpleCov SourceFile instances with additional collection helper
 # methods for calculating coverage across them etc.
 module SimpleCov
@@ -5,25 +7,25 @@ module SimpleCov
     # Returns the count of lines that have coverage
     def covered_lines
       return 0.0 if empty?
-      map { |f| f.covered_lines.count }.inject(&:+)
+      map { |f| f.covered_lines.count }.inject(:+)
     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(&:+)
+      map { |f| f.missed_lines.count }.inject(:+)
     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(&:+)
+      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(&:+)
+      map { |f| f.skipped_lines.count }.inject(:+)
     end
 
     # Computes the coverage based upon lines covered and lines missed for each file
@@ -53,7 +55,7 @@ module SimpleCov
     # @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)
+      Float(map { |f| f.covered_strength * f.lines_of_code }.inject(:+) / lines_of_code)
     end
   end
 end

data/lib/simplecov/filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SimpleCov
   #
   # Base filter class. Inherit from this to create custom filters,
@@ -24,13 +26,40 @@ module SimpleCov
       warn "#{Kernel.caller.first}: [DEPRECATION] #passes? is deprecated. Use #matches? instead."
       matches?(source_file)
     end
+
+    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)
+        SimpleCov::StringFilter
+      elsif filter_argument.is_a?(Regexp)
+        SimpleCov::RegexFilter
+      elsif filter_argument.is_a?(Array)
+        SimpleCov::ArrayFilter
+      elsif filter_argument.is_a?(Proc)
+        SimpleCov::BlockFilter
+      else
+        raise ArgumentError, "You have provided an unrecognized filter type"
+      end
+    end
   end
 
   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)
     def matches?(source_file)
-      (source_file.filename =~ /#{filter_argument}/)
+      source_file.project_filename.include?(filter_argument)
+    end
+  end
+
+  class RegexFilter < SimpleCov::Filter
+    # Returns true when the given source file's filename matches the
+    # regex configured when initializing this Filter with RegexFilter.new(/someregex/)
+    def matches?(source_file)
+      (source_file.project_filename =~ filter_argument)
     end
   end
 
@@ -43,11 +72,19 @@ module SimpleCov
   end
 
   class ArrayFilter < SimpleCov::Filter
-    # Returns true if any of the file paths passed in the given array matches the string
-    # configured when initializing this Filter with StringFilter.new(['some/path', 'other/path'])
+    def initialize(filter_argument)
+      filter_objects = filter_argument.map do |arg|
+        Filter.build_filter(arg)
+      end
+
+      super(filter_objects)
+    end
+
+    # Returns true if any of the filters in the array match the given source file.
+    # Configure this Filter like StringFilter.new(['some/path', /^some_regex/, Proc.new {|src_file| ... }])
     def matches?(source_files_list)
       filter_argument.any? do |arg|
-        source_files_list.filename =~ /#{arg}/
+        arg.matches?(source_files_list)
       end
     end
   end

data/lib/simplecov/formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SimpleCov
   # TODO: Documentation on how to build your own formatters
   module Formatter

data/lib/simplecov/formatter/multi_formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SimpleCov
   module Formatter
     class MultiFormatter

data/lib/simplecov/formatter/simple_formatter.rb

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

data/lib/simplecov/jruby_fix.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 if defined?(JRUBY_VERSION) && JRUBY_VERSION.to_f < 1.7
   require "jruby"
   java_import "org.jruby.ast.NodeType"

data/lib/simplecov/last_run.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "json"
 
 module SimpleCov
@@ -9,7 +11,9 @@ module SimpleCov
 
       def read
         return nil unless File.exist?(last_run_path)
-        JSON.parse(File.read(last_run_path))
+        json = File.read(last_run_path)
+        return nil if json.strip.empty?
+        JSON.parse(json)
       end
 
       def write(json)

data/lib/simplecov/lines_classifier.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SimpleCov
+  # Classifies whether lines are relevant for code coverage analysis.
+  # Comments & whitespace lines, and :nocov: token blocks, are considered not relevant.
+
+  class LinesClassifier
+    RELEVANT = 0
+    NOT_RELEVANT = nil
+
+    WHITESPACE_LINE = /^\s*$/
+    COMMENT_LINE = /^\s*#/
+    WHITESPACE_OR_COMMENT_LINE = Regexp.union(WHITESPACE_LINE, COMMENT_LINE)
+
+    def self.no_cov_line
+      /^(\s*)#(\s*)(\:#{SimpleCov.nocov_token}\:)/o
+    end
+
+    def self.no_cov_line?(line)
+      line =~ no_cov_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
+    rescue ArgumentError
+      # E.g., line contains an invalid byte sequence in UTF-8
+      false
+    end
+
+    def classify(lines)
+      skipping = false
+
+      lines.map do |line|
+        if self.class.no_cov_line?(line)
+          skipping = !skipping
+          NOT_RELEVANT
+        elsif skipping || self.class.whitespace_line?(line)
+          NOT_RELEVANT
+        else
+          RELEVANT
+        end
+      end
+    end
+  end
+end

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

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

data/lib/simplecov/profiles.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Profiles are SimpleCov configuration procs that can be easily
 # loaded using SimpleCov.start :rails and defined using

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,3 +1,5 @@
+# frozen_string_literal: true
+
 module SimpleCov
   class Railtie < ::Rails::Railtie
     rake_tasks do

data/lib/simplecov/railties/tasks.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rake/testtask"
 Rake::TestTask.new do |t|
   t.name = "simplecov"

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,3 +1,5 @@
+# frozen_string_literal: true
+
 require "digest/sha1"
 require "forwardable"
 
@@ -24,7 +26,6 @@ module SimpleCov
     # 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.dup.extend(SimpleCov::HashMergeHelper) unless original_result.is_a? SimpleCov::HashMergeHelper
       @original_result = original_result.freeze
       @files = SimpleCov::FileList.new(original_result.map do |filename, coverage|
         SimpleCov::SourceFile.new(filename, coverage) if File.file?(filename)

data/lib/simplecov/result_merger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "json"
 
 #
@@ -17,25 +19,31 @@ module SimpleCov
         File.join(SimpleCov.coverage_path, ".resultset.json.lock")
       end
 
-      # Loads the cached resultset from JSON and returns it as a Hash
+      # Loads the cached resultset from JSON and returns it as a Hash,
+      # caching it for subsequent accesses.
       def resultset
-        if stored_data
-          begin
-            JSON.parse(stored_data)
-          rescue
+        @resultset ||= begin
+          data = stored_data
+          if data
+            begin
+              JSON.parse(data) || {}
+            rescue
+              {}
+            end
+          else
             {}
           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
-        return unless File.exist?(resultset_path)
-        data = File.read(resultset_path)
-        return if data.nil? || data.length < 2
-        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
 
       # Gets the resultset hash and re-creates all included instances
@@ -54,26 +62,31 @@ module SimpleCov
         results
       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
+      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)
-        end
-        result = SimpleCov::Result.new(merged)
-        # Specify the command name
-        result.command_name = results.map(&:command_name).sort.join(", ")
-        result
+        merge_results(*results)
       end
 
       # Saves the given SimpleCov::Result in the resultset cache
       def store_result(result)
-        File.open(resultset_writelock, "w+") do |f|
-          f.flock(File::LOCK_EX)
+        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
@@ -83,6 +96,28 @@ module SimpleCov
         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
     end
   end
 end