simplecov 0.8.0.pre2 → 0.18.0.beta1

data/lib/simplecov/last_run.rb

@@ -1,20 +1,28 @@
-module SimpleCov::LastRun
-  class << self
-    def last_run_path
-      File.join(SimpleCov.coverage_path, '.last_run.json')
-    end
+# frozen_string_literal: true
 
-    def read
-      return nil unless File.exist?(last_run_path)
+require "json"
 
-      SimpleCov::JSON.parse(File.read(last_run_path))
-    end
+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)
 
-    def write(json)
-      File.open(last_run_path, "w+") do |f|
-        f.puts SimpleCov::JSON.dump(json)
+        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*$/.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)
+      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 @@
-ENV['SIMPLECOV_NO_DEFAULTS'] = 'yes, no defaults'
-require 'simplecov'
+# frozen_string_literal: true
+
+ENV["SIMPLECOV_NO_DEFAULTS"] = "yes, no defaults"
+require "simplecov"

data/lib/simplecov/profiles.rb

@@ -1,29 +1,35 @@
-#
-# 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 SimpleCov::Profiles < Hash
+# frozen_string_literal: true
+
+module SimpleCov
   #
-  # Define a SimpleCov profile:
-  #   SimpleCov.profiles.define 'rails' do
-  #     # Same as SimpleCov.configure do .. here
+  # 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
   #
-  def define(name, &blk)
-    name = name.to_sym
-    raise "SimpleCov Profile '#{name}' is already defined" unless self[name].nil?
-    self[name] = blk
-  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?
 
-  #
-  # 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 has_key?(name)
-    SimpleCov.configure(&self[name])
+      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/result.rb

@@ -1,36 +1,35 @@
-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
+    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.dup
-
-      # Squeeze filepaths (i.e. "/a/b/../c" becomes "/a/c")
-      @original_result.keys.each do |filename|
-        expanded_filename = File.expand_path filename
-        @original_result[expanded_filename] = @original_result.delete filename
-      end
-
-      @files = SimpleCov::FileList.new(@original_result.map do |filename, coverage|
-        SimpleCov::SourceFile.new(filename, coverage) if File.file?(filename)
+      @original_result = original_result.freeze
+      @files = SimpleCov::FileList.new(original_result.map do |filename, coverage|
+        SimpleCov::SourceFile.new(filename, JSON.parse(JSON.dump(coverage), :symbolize_names => true)) if File.file?(filename.to_s)
       end.compact.sort_by(&:filename))
-
       filter!
     end
 
@@ -44,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)
@@ -110,21 +59,43 @@ 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 = SimpleCov::Result.new(
+        symbolize_names_of_coverage_results(data["coverage"])
+      )
+
       result.command_name = command_name
       result.created_at = Time.at(data["timestamp"])
       result
     end
 
-    private
+    # Manage symbolize the keys of coverage hash.
+    # JSON.parse gives coverage hash with stringified keys what breaks some logics
+    # inside the process that expects them as symboles.
+    #
+    # @return [Hash]
+    def self.symbolize_names_of_coverage_results(coverage_data)
+      coverage_data.each_with_object({}) do |(file_name, file_coverage_result), coverage_results|
+        coverage_results[file_name] = file_coverage_result.each_with_object({}) do |(k, v), cov_elem|
+          cov_elem[k.to_sym] = v
+        end
+      end
+    end
+
+  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

data/lib/simplecov/result_merger.rb

@@ -1,74 +1,124 @@
-#
-# 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.json cache file
-    def resultset_path
-      File.join(SimpleCov.coverage_path, '.resultset.json')
-    end
+# frozen_string_literal: true
+
+require "json"
 
-    # Loads the cached resultset from YAML and returns it as a Hash
-    def resultset
-      if stored_data
-        SimpleCov::JSON.parse(stored_data)
-      else
-        {}
+module SimpleCov
+  #
+  # Singleton that is responsible for caching, loading and merging
+  # SimpleCov::Results into a single result for coverage analysis based
+  # upon multiple test suites.
+  #
+  module ResultMerger
+    class << self
+      # The path to the .resultset.json cache file
+      def resultset_path
+        File.join(SimpleCov.coverage_path, ".resultset.json")
       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
+      def resultset_writelock
+        File.join(SimpleCov.coverage_path, ".resultset.json.lock")
       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
+      # 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 StandardError
+              {}
+            end
+          else
+            {}
+          end
         end
       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)
+      # 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
+
+      # 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
+          results << result if (Time.now - result.created_at) < SimpleCov.merge_timeout
+        end
+        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)
+        parsed_results = JSON.parse(JSON.dump(results.map(&:original_result)), :symbolize_names => true)
+        combined_result = SimpleCov::Combine::ResultsCombiner.combine(*parsed_results)
+        result = SimpleCov::Result.new(combined_result)
+        # 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
+        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
-      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|
-        f.puts SimpleCov::JSON.dump(new_set)
+      # Clear out the previously cached .resultset
+      def clear_resultset
+        @resultset = nil
       end
-      true
     end
   end
 end