simplecov 0.6.4 → 0.17.1

data/lib/simplecov/defaults.rb

@@ -1,57 +1,52 @@
-# Load default formatter gem
-require 'simplecov-html'
-
-SimpleCov.adapters.define 'root_filter' do
-  # Exclude all files outside of simplecov root
-  add_filter do |src|
-    !(src.filename =~ /^#{SimpleCov.root}/)
-  end
-end
-
-SimpleCov.adapters.define 'test_frameworks' do
-  add_filter '/test/'
-  add_filter '/features/'
-  add_filter '/spec/'
-  add_filter '/autotest/'
-end
-
-SimpleCov.adapters.define 'rails' do
-  load_adapter 'test_frameworks'
-
-  add_filter '/config/'
-  add_filter '/db/'
-  add_filter '/vendor/bundle/'
+# frozen_string_literal: true
 
-  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_adapter '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 : 1
-  end
-  SimpleCov.at_exit.call
-  exit @exit_status if @exit_status # Force exit with stored status (see github issue #5)
+  # If we are in a different process than called start, don't interfere.
+  next if SimpleCov.pid != Process.pid
+
+  SimpleCov.set_exit_exception
+  SimpleCov.run_exit_tasks!
 end
 
+# Autoload config from ~/.simplecov if present
+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
+      $stderr.puts "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

@@ -0,0 +1,10 @@
+# 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,61 @@
+# frozen_string_literal: true
+
 # 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
+module SimpleCov
+  class 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
 
-  # 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
+    # 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
 
-  # 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 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
+    # Returns the count of skipped lines
+    def skipped_lines
+      return 0.0 if empty?
+      map { |f| f.skipped_lines.count }.inject(:+)
+    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 for each file
+    # Returns an array with all coverage percentages
+    def covered_percentages
+      map(&:covered_percent)
+    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
+    # Finds the least covered file and returns that file's name
+    def least_covered_file
+      sort_by(&:covered_percent).first.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
-  def covered_strength
-    return 0 if empty? or lines_of_code == 0
-    map {|f| f.covered_strength }.inject(&:+) / size
+    # 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
   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,48 @@ module SimpleCov
       @filter_argument = filter_argument
     end
 
-    def matches?(source_file)
+    def matches?(_)
       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 +70,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,7 +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/simple_formatter"
+require "simplecov/formatter/multi_formatter"

data/lib/simplecov/formatter/multi_formatter.rb

@@ -0,0 +1,34 @@
+# 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 => e
+              STDERR.puts("Formatter #{formatter} failed with #{e.class}: #{e.message} (#{e.backtrace.first})")
+              nil
+            end
+          end
+        end
+      end
+
+      def self.new(formatters = nil)
+        Class.new do
+          define_method :formatters do
+            @formatters ||= Array(formatters)
+          end
+          include InstanceMethods
+        end
+      end
+
+      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 @@
+# frozen_string_literal: true
+
 #
 # 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"
+module SimpleCov
+  module Formatter
+    class SimpleFormatter
+      # Takes a SimpleCov::Result and generates a string out of it
+      def format(result)
+        output = "".dup
+        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

data/lib/simplecov/jruby_fix.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+if defined?(JRUBY_VERSION) && JRUBY_VERSION.to_f < 1.7
+  require "jruby"
+  java_import "org.jruby.ast.NodeType"
+
+  # Coverage for JRuby < 1.7.0 does not work correctly
+  #
+  #  - does not distinguish lines that cannot be executed
+  #  - does (partial) coverage for files loaded before `Coverage.start`.
+  #  - does not expand a path like `lib/../spec` to `spec`.
+  #
+  # This monkey patches Coverage to address those issues
+  module Coverage
+    class << self
+      alias __broken_result__ result
+
+      def result # rubocop:disable Metrics/MethodLength
+        fixed = {}
+        __broken_result__.each do |path, executed_lines|
+          next unless File.file? path
+
+          covered_lines = executed_lines.dup
+
+          process = lambda do |node|
+            if node.node_type == NodeType::NEWLINENODE
+              pos = node.position
+              covered_lines[pos.line] ||= 0
+            end
+            node.child_nodes.each(&process)
+          end
+
+          process[JRuby.parse(File.read(path), path)]
+
+          if (first = covered_lines.detect { |x| x }) && first > 0
+            fixed[File.expand_path(path)] = covered_lines
+          end
+        end
+
+        fixed
+      end
+    end
+  end
+end

data/lib/simplecov/last_run.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SimpleCov
+  module LastRun
+    class << self
+      def last_run_path
+        File.join(SimpleCov.coverage_path, ".last_run.json")
+      end
+
+      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)
+      end
+
+      def write(json)
+        File.open(last_run_path, "w+") do |f|
+          f.puts JSON.pretty_generate(json)
+        end
+      end
+    end
+  end
+end

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