simplecov 0.6.0 → 0.22.0

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

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_relative "formatter/simple_formatter"
+require_relative "formatter/multi_formatter"

data/lib/simplecov/last_run.rb

@@ -0,0 +1,28 @@
+# 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, symbolize_names: true)
+      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*$/.freeze
+    COMMENT_LINE = /^\s*#/.freeze
+    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)
+      no_cov_line.match?(line)
+    rescue ArgumentError
+      # E.g., line contains an invalid byte sequence in UTF-8
+      false
+    end
+
+    def self.whitespace_line?(line)
+      WHITESPACE_OR_COMMENT_LINE.match?(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

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

data/lib/simplecov/process.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Process
+  class << self
+    def fork_with_simplecov(&block)
+      if defined?(SimpleCov) && SimpleCov.running
+        fork_without_simplecov do
+          SimpleCov.at_fork.call(Process.pid)
+          block.call if block_given?
+        end
+      else
+        fork_without_simplecov(&block)
+      end
+    end
+
+    alias fork_without_simplecov fork
+    alias fork fork_with_simplecov
+  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/profiles.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+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:
+    #   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/result.rb

@@ -1,27 +1,37 @@
-require 'digest/sha1'
+# frozen_string_literal: true
+
+require "digest/sha1"
+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
+    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, :total_branches, :covered_branches, :missed_branches, :coverage_statistics, :coverage_statistics_by_file
+    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)
+    def initialize(original_result, command_name: nil, created_at: nil)
+      result = original_result
+      @original_result = result.freeze
+      @command_name = command_name
+      @created_at = created_at
+      @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
@@ -36,55 +46,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 @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 @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 @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)
@@ -101,21 +62,29 @@ 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
     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
+      hash.map do |command_name, data|
+        new(data.fetch("coverage"), command_name: command_name, created_at: Time.at(data["timestamp"]))
+      end
     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_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