simplecov-patched 0.14.2

data/lib/simplecov/result_merger.rb

@@ -0,0 +1,95 @@
+require "json"
+
+#
+# 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
+  module ResultMerger
+    class << self
+      # The path to the .resultset.json cache file
+      def resultset_path
+        File.join(SimpleCov.coverage_path, ".resultset.json")
+      end
+
+      def resultset_writelock
+        File.join(SimpleCov.coverage_path, ".resultset.json.lock")
+      end
+
+      # Loads the cached resultset from JSON and returns it as a Hash,
+      # caching it for subsequent accesses.
+      def resultset(force_reload = false)
+        @resultset = nil if force_reload
+
+        @resultset ||= if (data = stored_data)
+                         begin
+                           JSON.parse(data) || {}
+                         rescue
+                           {}
+                         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
+      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
+          end
+        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)
+        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
+        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)
+          new_set = resultset(true)
+          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
+    end
+  end
+end

data/lib/simplecov/source_file.rb

@@ -0,0 +1,196 @@
+module SimpleCov
+  #
+  # Representation of a source file including it's coverage data, source code,
+  # source lines and featuring helpers to interpret that data.
+  #
+  class SourceFile
+    # Representation of a single line in a source file including
+    # this specific line's source code, line_number and code coverage,
+    # with the coverage being either nil (coverage not applicable, e.g. comment
+    # line), 0 (line not covered) or >1 (the amount of times the line was
+    # executed)
+    class Line
+      # The source code for this line. Aliased as :source
+      attr_reader :src
+      # The line number in the source file. Aliased as :line, :number
+      attr_reader :line_number
+      # The coverage data for this line: either nil (never), 0 (missed) or >=1 (times covered)
+      attr_reader :coverage
+      # Whether this line was skipped
+      attr_reader :skipped
+
+      # Lets grab some fancy aliases, shall we?
+      alias source src
+      alias line line_number
+      alias number line_number
+
+      def initialize(src, line_number, coverage)
+        raise ArgumentError, "Only String accepted for source" unless src.is_a?(String)
+        raise ArgumentError, "Only Integer accepted for line_number" unless line_number.is_a?(Integer)
+        raise ArgumentError, "Only Integer and nil accepted for coverage" unless coverage.is_a?(Integer) || coverage.nil?
+        @src         = src
+        @line_number = line_number
+        @coverage    = coverage
+        @skipped     = false
+      end
+
+      # Returns true if this is a line that should have been covered, but was not
+      def missed?
+        !never? && !skipped? && coverage.zero?
+      end
+
+      # Returns true if this is a line that has been covered
+      def covered?
+        !never? && !skipped? && coverage > 0
+      end
+
+      # Returns true if this line is not relevant for coverage
+      def never?
+        !skipped? && coverage.nil?
+      end
+
+      # Flags this line as skipped
+      def skipped!
+        @skipped = true
+      end
+
+      # Returns true if this line was skipped, false otherwise. Lines are skipped if they are wrapped with
+      # # :nocov: comment lines.
+      def skipped?
+        !!skipped
+      end
+
+      # The status of this line - either covered, missed, skipped or never. Useful i.e. for direct use
+      # as a css class in report generation
+      def status
+        return "skipped" if skipped?
+        return "never" if never?
+        return "missed" if missed?
+        return "covered" if covered?
+      end
+    end
+
+    # The full path to this source file (e.g. /User/colszowka/projects/simplecov/lib/simplecov/source_file.rb)
+    attr_reader :filename
+    # The array of coverage data received from the Coverage.result
+    attr_reader :coverage
+
+    def initialize(filename, coverage)
+      @filename = filename
+      @coverage = coverage
+    end
+
+    # The source code for this file. Aliased as :source
+    def src
+      # We intentionally read source code lazily to
+      # suppress reading unused source code.
+      @src ||= File.open(filename, "rb", &:readlines)
+    end
+    alias source src
+
+    # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line,
+    # and thus including coverage data. Aliased as :source_lines
+    def lines
+      @lines ||= build_lines
+    end
+    alias source_lines lines
+
+    def build_lines
+      coverage_exceeding_source_warn if coverage.size > src.size
+
+      lines = src.map.with_index(1) do |src, i|
+        SimpleCov::SourceFile::Line.new(src, i, coverage[i - 1])
+      end
+
+      process_skipped_lines(lines)
+    end
+
+    # Warning to identify condition from Issue #56
+    def coverage_exceeding_source_warn
+      $stderr.puts "Warning: coverage data provided by Coverage [#{coverage.size}] exceeds number of lines in #{filename} [#{src.size}]"
+    end
+
+    # Access SimpleCov::SourceFile::Line source lines by line number
+    def line(number)
+      lines[number - 1]
+    end
+
+    # The coverage for this file in percent. 0 if the file has no relevant lines
+    def covered_percent
+      return 100.0 if no_lines?
+
+      return 0.0 if relevant_lines.zero?
+
+      Float(covered_lines.size * 100.0 / relevant_lines.to_f)
+    end
+
+    def covered_strength
+      return 0.0 if relevant_lines.zero?
+
+      round_float(lines_strength / relevant_lines.to_f, 1)
+    end
+
+    def no_lines?
+      lines.length.zero? || (lines.length == never_lines.size)
+    end
+
+    def lines_strength
+      lines.map(&:coverage).compact.reduce(:+)
+    end
+
+    def relevant_lines
+      lines.size - never_lines.size - skipped_lines.size
+    end
+
+    # Returns all covered lines as SimpleCov::SourceFile::Line
+    def covered_lines
+      @covered_lines ||= lines.select(&:covered?)
+    end
+
+    # Returns all lines that should have been, but were not covered
+    # as instances of SimpleCov::SourceFile::Line
+    def missed_lines
+      @missed_lines ||= lines.select(&:missed?)
+    end
+
+    # Returns all lines that are not relevant for coverage as
+    # SimpleCov::SourceFile::Line instances
+    def never_lines
+      @never_lines ||= lines.select(&:never?)
+    end
+
+    # Returns all lines that were skipped as SimpleCov::SourceFile::Line instances
+    def skipped_lines
+      @skipped_lines ||= lines.select(&:skipped?)
+    end
+
+    # Returns the number of relevant lines (covered + missed)
+    def lines_of_code
+      covered_lines.size + missed_lines.size
+    end
+
+    # Will go through all source files and mark lines that are wrapped within # :nocov: comment blocks
+    # as skipped.
+    def process_skipped_lines(lines)
+      skipping = false
+
+      lines.each do |line|
+        if line.src =~ /^([\s]*)#([\s]*)(\:#{SimpleCov.nocov_token}\:)/
+          skipping = !skipping
+          line.skipped!
+        elsif skipping
+          line.skipped!
+        end
+      end
+    end
+
+  private
+
+    # ruby 1.9 could use Float#round(places) instead
+    # @return [Float]
+    def round_float(float, places)
+      factor = Float(10 * places)
+      Float((float * factor).round / factor)
+    end
+  end
+end

data/lib/simplecov/version.rb

@@ -0,0 +1,25 @@
+module SimpleCov
+  version = "0.14.2"
+
+  def version.to_a
+    split(".").map(&:to_i)
+  end
+
+  def version.major
+    to_a[0]
+  end
+
+  def version.minor
+    to_a[1]
+  end
+
+  def version.patch
+    to_a[2]
+  end
+
+  def version.pre
+    to_a[3]
+  end
+
+  VERSION = version
+end

data/spec/1_8_fallbacks_spec.rb

@@ -0,0 +1,31 @@
+require "helper"
+
+# Tests that verify that on 1.8 versions of ruby, simplecov simply
+# does not launch and does not cause errors on the way
+#
+# TODO: This should be expanded upon all methods that could potentially
+# be called in a test/spec-helper simplecov config block
+#
+if RUBY_VERSION.start_with? "1.8"
+  describe "Ruby 1.8 fallback" do
+    it "return false when calling SimpleCov.start" do
+      expect(SimpleCov.start).to be false
+    end
+
+    it "return false when calling SimpleCov.start with a block" do
+      expect(SimpleCov.start { raise "Shouldn't reach this!" }).to be false
+    end
+
+    it "return false when calling SimpleCov.configure with a block" do
+      expect(SimpleCov.configure { raise "Shouldn't reach this!" }).to be false
+    end
+
+    it "allow to define a profile" do
+      expect do
+        SimpleCov.profiles.define "testprofile" do
+          add_filter "/config/"
+        end
+      end.not_to raise_error
+    end
+  end
+end

data/spec/command_guesser_spec.rb

@@ -0,0 +1,48 @@
+require "helper"
+
+if SimpleCov.usable?
+  describe SimpleCov::CommandGuesser do
+    subject { SimpleCov::CommandGuesser }
+    it 'correctly guesses "Unit Tests" for unit tests' do
+      subject.original_run_command = "/some/path/test/units/foo_bar_test.rb"
+      expect(subject.guess).to eq("Unit Tests")
+      subject.original_run_command = "test/units/foo.rb"
+      expect(subject.guess).to eq("Unit Tests")
+      subject.original_run_command = "test/foo.rb"
+      expect(subject.guess).to eq("Unit Tests")
+      subject.original_run_command = "test/{models,helpers,unit}/**/*_test.rb"
+      expect(subject.guess).to eq("Unit Tests")
+    end
+
+    it 'correctly guesses "Functional Tests" for functional tests' do
+      subject.original_run_command = "/some/path/test/functional/foo_bar_controller_test.rb"
+      expect(subject.guess).to eq("Functional Tests")
+      subject.original_run_command = "test/{controllers,mailers,functional}/**/*_test.rb"
+      expect(subject.guess).to eq("Functional Tests")
+    end
+
+    it 'correctly guesses "Integration Tests" for integration tests' do
+      subject.original_run_command = "/some/path/test/integration/foo_bar_controller_test.rb"
+      expect(subject.guess).to eq("Integration Tests")
+      subject.original_run_command = "test/integration/**/*_test.rb"
+      expect(subject.guess).to eq("Integration Tests")
+    end
+
+    it 'correctly guesses "Cucumber Features" for cucumber features' do
+      subject.original_run_command = "features"
+      expect(subject.guess).to eq("Cucumber Features")
+      subject.original_run_command = "cucumber"
+      expect(subject.guess).to eq("Cucumber Features")
+    end
+
+    it 'correctly guesses "RSpec" for RSpec' do
+      subject.original_run_command = "/some/path/spec/foo.rb"
+      expect(subject.guess).to eq("RSpec")
+    end
+
+    it "defaults to RSpec because RSpec constant is defined" do
+      subject.original_run_command = "some_arbitrary_command with arguments"
+      expect(subject.guess).to eq("RSpec")
+    end
+  end
+end

data/spec/config_loader_spec.rb

@@ -0,0 +1,14 @@
+require "helper"
+
+describe "loading config" do
+  context "without ENV[HOME]" do
+    it "shouldn't raise any errors" do
+      home = ENV.delete("HOME")
+      begin
+        expect { load "simplecov/load_global_config.rb" }.not_to raise_error
+      ensure
+        ENV["HOME"] = home
+      end
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,35 @@
+require "helper"
+
+describe SimpleCov::Configuration do
+  let(:config_class) do
+    Class.new do
+      include SimpleCov::Configuration
+    end
+  end
+  let(:config) { config_class.new }
+
+  describe "#tracked_files" do
+    context "when configured" do
+      let(:glob) { "{app,lib}/**/*.rb" }
+      before { config.track_files(glob) }
+
+      it "returns the configured glob" do
+        expect(config.tracked_files).to eq glob
+      end
+
+      context "and configured again with nil" do
+        before { config.track_files(nil) }
+
+        it "returns nil" do
+          expect(config.tracked_files).to be_nil
+        end
+      end
+    end
+
+    context "when unconfigured" do
+      it "returns nil" do
+        expect(config.tracked_files).to be_nil
+      end
+    end
+  end
+end