simplecov 0.8.0.pre2 → 0.18.0.beta1

data/lib/simplecov/defaults.rb

@@ -1,92 +1,52 @@
-# Load default formatter gem
-require 'simplecov-html'
-
-SimpleCov.profiles.define 'root_filter' do
-  # Exclude all files outside of simplecov root
-  add_filter do |src|
-    !(src.filename =~ /^#{Regexp.escape(SimpleCov.root)}/)
-  end
-end
-
-SimpleCov.profiles.define 'test_frameworks' do
-  add_filter '/test/'
-  add_filter '/features/'
-  add_filter '/spec/'
-  add_filter '/autotest/'
-end
+# frozen_string_literal: true
 
-SimpleCov.profiles.define 'rails' do
-  load_profile 'test_frameworks'
-
-  add_filter '/config/'
-  add_filter '/db/'
-  add_filter '/vendor/bundle/'
-
-  add_group 'Controllers', 'app/controllers'
-  add_group 'Models', 'app/models'
-  add_group 'Mailers', 'app/mailers'
-  add_group 'Helpers', 'app/helpers'
-  add_group 'Libraries', 'lib'
-  add_group 'Plugins', 'vendor/plugins'
-end
+# Load default formatter gem
+require "simplecov-html"
+require "pathname"
+require "simplecov/profiles/root_filter"
+require "simplecov/profiles/test_frameworks"
+require "simplecov/profiles/bundler_filter"
+require "simplecov/profiles/hidden_filter"
+require "simplecov/profiles/rails"
 
 # Default configuration
 SimpleCov.configure do
   formatter SimpleCov::Formatter::HTMLFormatter
+  load_profile "bundler_filter"
+  load_profile "hidden_filter"
   # Exclude files outside of SimpleCov.root
-  load_profile 'root_filter'
+  load_profile "root_filter"
 end
 
 # Gotta stash this a-s-a-p, see the CommandGuesser class and i.e. #110 for further info
-SimpleCov::CommandGuesser.original_run_command = "#{$0} #{ARGV.join(" ")}"
+SimpleCov::CommandGuesser.original_run_command = "#{$PROGRAM_NAME} #{ARGV.join(' ')}"
 
 at_exit do
-  # Store the exit status of the test run since it goes away after calling the at_exit proc...
-  if $! #was an exception thrown?
-    #if it was a SystemExit, use the accompanying status
-    #otherwise set a non-zero status representing termination by some other exception
-    #(see github issue 41)
-    @exit_status = $!.is_a?(SystemExit) ? $!.status : SimpleCov::ExitCodes::EXCEPTION
-  else
-    @exit_status = 0
-  end
-
-  SimpleCov.at_exit.call
+  # If we are in a different process than called start, don't interfere.
+  next if SimpleCov.pid != Process.pid
 
-  if SimpleCov.result? # Result has been computed
-    covered_percent = SimpleCov.result.covered_percent.round(2)
-
-    if @exit_status == 0 # No other errors
-      @exit_status = if covered_percent < SimpleCov.minimum_coverage
-        $stderr.puts "Coverage (%.2f%%) is below the expected minimum coverage (%.2f%%)." % \
-                     [covered_percent, SimpleCov.minimum_coverage]
-
-        SimpleCov::ExitCodes::MINIMUM_COVERAGE
-
-      elsif (last_run = SimpleCov::LastRun.read)
-        diff = last_run['result']['covered_percent'] - covered_percent
-        if diff > SimpleCov.maximum_coverage_drop
-          $stderr.puts "Coverage has dropped by %.2f%% since the last time (maximum allowed: %.2f%%)." % \
-                       [diff, SimpleCov.maximum_coverage_drop]
-
-          SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
-        end
-      end
-    end
-
-    metrics = {
-      :result => { :covered_percent => covered_percent }
-    }
-    SimpleCov::LastRun.write(metrics)
-  end
-
-  exit @exit_status if @exit_status # Force exit with stored status (see github issue #5)
+  SimpleCov.set_exit_exception
+  SimpleCov.run_exit_tasks!
 end
 
 # Autoload config from ~/.simplecov if present
-global_config_path = File.join(File.expand_path("~"), '.simplecov')
-load global_config_path if File.exist?(global_config_path)
+require "simplecov/load_global_config"
 
 # Autoload config from .simplecov if present
-config_path = File.join(SimpleCov.root, '.simplecov')
-load config_path if File.exist?(config_path)
+# Recurse upwards until we find .simplecov or reach the root directory
+
+config_path = Pathname.new(SimpleCov.root)
+loop do
+  filename = config_path.join(".simplecov")
+  if filename.exist?
+    begin
+      load filename
+    rescue LoadError, StandardError
+      warn "Warning: Error occurred while trying to load #{filename}. " \
+        "Error message: #{$!.message}"
+    end
+    break
+  end
+  config_path, = config_path.split
+  break if config_path.root?
+end

data/lib/simplecov/exit_codes.rb

@@ -1,5 +1,10 @@
-module SimpleCov::ExitCodes
-  EXCEPTION = 1
-  MINIMUM_COVERAGE = 2
-  MAXIMUM_COVERAGE_DROP = 3
+# frozen_string_literal: true
+
+module SimpleCov
+  module ExitCodes
+    SUCCESS = 0
+    EXCEPTION = 1
+    MINIMUM_COVERAGE = 2
+    MAXIMUM_COVERAGE_DROP = 3
+  end
 end

data/lib/simplecov/file_list.rb

@@ -1,44 +1,88 @@
-# An array of SimpleCov SourceFile instances with additional collection helper
-# methods for calculating coverage across them etc.
-class SimpleCov::FileList < Array
-  # Returns the count of lines that have coverage
-  def covered_lines
-    return 0.0 if empty?
-    map {|f| f.covered_lines.count }.inject(&:+)
-  end
+# frozen_string_literal: true
 
-  # Returns the count of lines that have been missed
-  def missed_lines
-    return 0.0 if empty?
-    map {|f| f.missed_lines.count }.inject(&:+)
-  end
+module SimpleCov
+  # An array of SimpleCov SourceFile instances with additional collection helper
+  # methods for calculating coverage across them etc.
+  class FileList < Array
+    # Returns the count of lines that have coverage
+    def covered_lines
+      return 0.0 if empty?
 
-  # 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
+      map { |f| f.covered_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
+    # Returns the count of lines that have been missed
+    def missed_lines
+      return 0.0 if empty?
 
-  # Returns the overall amount of relevant lines of code across all files in this list
-  def lines_of_code
-    covered_lines + missed_lines
-  end
+      map { |f| f.missed_lines.count }.inject(:+)
+    end
 
-  # Computes the coverage based upon lines covered and lines missed
-  def covered_percent
-    return 100.0 if empty? or lines_of_code == 0
-    covered_lines * 100.0 / lines_of_code
-  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
+
+    # Computes the coverage based upon lines covered and lines missed for each file
+    # Returns an array with all coverage percentages
+    def covered_percentages
+      map(&:covered_percent)
+    end
+
+    # Finds the least covered file and returns that file's name
+    def least_covered_file
+      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
+    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)
+    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)
+    end
+
+    # Return total count of branches in all files
+    def total_branches
+      return 0 if empty?
+
+      map { |file| file.total_branches.count }.inject(:+)
+    end
+
+    # Return total count of covered branches
+    def covered_branches
+      return 0 if empty?
+
+      map { |file| file.covered_branches.count }.inject(:+)
+    end
+
+    # Return total count of covered branches
+    def missed_branches
+      return 0 if empty?
 
-  # Computes the strength (hits / line) based upon lines covered and lines missed
-  def covered_strength
-    return 0 if empty? or lines_of_code == 0
-    map {|f| f.covered_strength }.inject(&:+).to_f / size
+      map { |file| file.missed_branches.count }.inject(:+)
+    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,
@@ -16,21 +18,49 @@ module SimpleCov
       @filter_argument = filter_argument
     end
 
-    def matches?(source_file)
+    def matches?(_source_file)
       raise "The base filter class is not intended for direct use"
     end
 
     def passes?(source_file)
-      warn "DEPRECATION: SimpleCov::Filter#passes?(x) has been renamed to #matches?. Please update your custom filters accordingly!"
+      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
 
@@ -41,4 +71,22 @@ module SimpleCov
       filter_argument.call(source_file)
     end
   end
+
+  class ArrayFilter < SimpleCov::Filter
+    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|
+        arg.matches?(source_files_list)
+      end
+    end
+  end
 end

data/lib/simplecov/formatter.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module SimpleCov
   # TODO: Documentation on how to build your own formatters
   module Formatter
   end
 end
 
-require 'simplecov/formatter/simple_formatter'
-require 'simplecov/formatter/multi_formatter'
+require "simplecov/formatter/simple_formatter"
+require "simplecov/formatter/multi_formatter"

data/lib/simplecov/formatter/multi_formatter.rb

@@ -1,25 +1,34 @@
-class SimpleCov::Formatter::MultiFormatter
-  def self.[](*args)
-    Class.new(self) do
-      define_method :formatters do
-        @formatters ||= args
+# frozen_string_literal: true
+
+module SimpleCov
+  module Formatter
+    class MultiFormatter
+      module InstanceMethods
+        def format(result)
+          formatters.map do |formatter|
+            begin
+              formatter.new.format(result)
+            rescue StandardError => e
+              warn("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
+              nil
+            end
+          end
+        end
       end
-    end
-  end
 
-  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
+      def self.new(formatters = nil)
+        Class.new do
+          define_method :formatters do
+            @formatters ||= Array(formatters)
+          end
+          include InstanceMethods
+        end
       end
-    end
-  end
 
-  def formatters
-    @formatters ||= []
+      def self.[](*args)
+        warn "#{Kernel.caller.first}: [DEPRECATION] ::[] is deprecated. Use ::new instead."
+        new(Array([*args]))
+      end
+    end
   end
-
 end

data/lib/simplecov/formatter/simple_formatter.rb

@@ -1,19 +1,25 @@
-#
-# A ridiculously simple formatter for SimpleCov results.
-#
-class SimpleCov::Formatter::SimpleFormatter
-  # Takes a SimpleCov::Result and generates a string out of it
-  def format(result)
-    output = ""
-    result.groups.each do |name, files|
-      output << "Group: #{name}\n"
-      output << "="*40
-      output << "\n"
-      files.each do |file|
-        output << "#{file.filename} (coverage: #{file.covered_percent.round(2)}%)\n"
+# frozen_string_literal: true
+
+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 = +""
+        result.groups.each do |name, files|
+          output << "Group: #{name}\n"
+          output << "=" * 40
+          output << "\n"
+          files.each do |file|
+            output << "#{file.filename} (coverage: #{file.covered_percent.round(2)}%)\n"
+          end
+          output << "\n"
+        end
+        output
       end
-      output << "\n"
     end
-    output
   end
 end