simplecov 0.14.1 → 0.15.1

data/lib/simplecov/result_merger.rb

@@ -17,25 +17,31 @@ module SimpleCov
         File.join(SimpleCov.coverage_path, ".resultset.json.lock")
       end
 
-      # Loads the cached resultset from JSON and returns it as a Hash
+      # Loads the cached resultset from JSON and returns it as a Hash,
+      # caching it for subsequent accesses.
       def resultset
-        if stored_data
-          begin
-            JSON.parse(stored_data)
-          rescue
+        @resultset ||= begin
+          data = stored_data
+          if data
+            begin
+              JSON.parse(data) || {}
+            rescue
+              {}
+            end
+          else
             {}
           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
+        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
@@ -76,8 +82,9 @@ module SimpleCov
 
       # 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)
+        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
@@ -87,6 +94,28 @@ module SimpleCov
         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
+
+      # Clear out the previously cached .resultset
+      def clear_resultset
+        @resultset = nil
+      end
     end
   end
 end

data/lib/simplecov/source_file.rb

@@ -80,6 +80,11 @@ module SimpleCov
       @coverage = coverage
     end
 
+    # The path to this source file relative to the projects directory
+    def project_filename
+      @filename.sub(/^#{SimpleCov.root}/, "")
+    end
+
     # The source code for this file. Aliased as :source
     def src
       # We intentionally read source code lazily to
@@ -175,7 +180,7 @@ module SimpleCov
       skipping = false
 
       lines.each do |line|
-        if line.src =~ /^([\s]*)#([\s]*)(\:#{SimpleCov.nocov_token}\:)/
+        if line.src =~ SimpleCov::LinesClassifier.no_cov_line
           skipping = !skipping
           line.skipped!
         elsif skipping

data/lib/simplecov/version.rb

@@ -1,25 +1,3 @@
 module SimpleCov
-  version = "0.14.1"
-
-  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
+  VERSION = "0.15.1".freeze
 end

data/lib/simplecov.rb

@@ -55,7 +55,7 @@ module SimpleCov
 
     #
     # Finds files that were to be tracked but were not loaded and initializes
-    # their coverage to zero.
+    # the line-by-line coverage to zero (if relevant) or nil (comments / whitespace etc).
     #
     def add_not_loaded_files(result)
       if tracked_files
@@ -63,7 +63,7 @@ module SimpleCov
         Dir[tracked_files].each do |file|
           absolute = File.expand_path(file)
 
-          result[absolute] ||= [0] * File.foreach(absolute).count
+          result[absolute] ||= LinesClassifier.new.classify(File.foreach(absolute))
         end
       end
 
@@ -75,23 +75,21 @@ module SimpleCov
     # from cache using SimpleCov::ResultMerger if use_merging is activated (default)
     #
     def result
-      # Ensure the variable is defined to avoid ruby warnings
-      @result = nil unless defined?(@result)
+      return @result if result?
 
       # Collect our coverage result
-      if running && !result?
+      if running
         @result = SimpleCov::Result.new add_not_loaded_files(Coverage.result)
       end
 
       # If we're using merging of results, store the current result
-      # first, then merge the results and return those
+      # first (if there is one), then merge the results and return those
       if use_merging
         SimpleCov::ResultMerger.store_result(@result) if result?
-
-        SimpleCov::ResultMerger.merged_result
-      else
-        @result
+        @result = SimpleCov::ResultMerger.merged_result
       end
+
+      @result
     ensure
       self.running = false
     end
@@ -158,6 +156,13 @@ module SimpleCov
         false
       end
     end
+
+    #
+    # Clear out the previously cached .result. Primarily useful in testing
+    #
+    def clear_result
+      @result = nil
+    end
   end
 end
 
@@ -172,6 +177,7 @@ require "simplecov/result"
 require "simplecov/filter"
 require "simplecov/formatter"
 require "simplecov/last_run"
+require "simplecov/lines_classifier"
 require "simplecov/raw_coverage"
 require "simplecov/result_merger"
 require "simplecov/command_guesser"

data/spec/defaults_spec.rb

@@ -0,0 +1,41 @@
+require "helper"
+
+if SimpleCov.usable?
+  describe SimpleCov do
+    skip "requires the default configuration" if ENV["SIMPLECOV_NO_DEFAULTS"]
+
+    context "profiles" do
+      let(:config_class) do
+        Class.new do
+          include SimpleCov::Configuration
+
+          def load_profile(name)
+            configure(&SimpleCov.profiles[name.to_sym])
+          end
+        end
+      end
+
+      let(:config) { config_class.new }
+
+      def filtered?(config, filename)
+        path = File.join(SimpleCov.root, filename)
+        file = SimpleCov::SourceFile.new(path, [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil])
+        config.filters.any? { |filter| filter.matches?(file) }
+      end
+
+      it "provides a sensible test_frameworks profile" do
+        config.load_profile(:test_frameworks)
+        expect(filtered?(config, "foo.rb")).not_to be
+        expect(filtered?(config, "test/foo.rb")).to be
+        expect(filtered?(config, "spec/bar.rb")).to be
+      end
+
+      it "provides a sensible rails profile" do
+        config.load_profile(:rails)
+        expect(filtered?(config, "app/models/user.rb")).not_to be
+        expect(filtered?(config, "db/schema.rb")).to be
+        expect(filtered?(config, "config/environment.rb")).to be
+      end
+    end
+  end
+end

data/spec/filters_spec.rb

@@ -26,6 +26,27 @@ if SimpleCov.usable?
       expect(SimpleCov::StringFilter.new("sample.rb")).to be_matches subject
     end
 
+    it "doesn't match a parent directory with a new SimpleCov::StringFilter" do
+      parent_dir_name = File.basename(File.expand_path("..", File.dirname(__FILE__)))
+      expect(SimpleCov::StringFilter.new(parent_dir_name)).not_to be_matches subject
+    end
+
+    it "matches a new SimpleCov::StringFilter '/fixtures/'" do
+      expect(SimpleCov::StringFilter.new("sample.rb")).to be_matches subject
+    end
+
+    it "matches a new SimpleCov::RegexFilter /\/fixtures\//" do
+      expect(SimpleCov::RegexFilter.new(/\/fixtures\//)).to be_matches subject
+    end
+
+    it "doesn't match a new SimpleCov::RegexFilter /^\/fixtures\//" do
+      expect(SimpleCov::RegexFilter.new(/^\/fixtures\//)).not_to be_matches subject
+    end
+
+    it "matches a new SimpleCov::RegexFilter /^\/spec\//" do
+      expect(SimpleCov::RegexFilter.new(/^\/spec\//)).to be_matches subject
+    end
+
     it "doesn't match a new SimpleCov::BlockFilter that is not applicable" do
       expect(SimpleCov::BlockFilter.new(proc { |s| File.basename(s.filename) == "foo.rb" })).not_to be_matches subject
     end
@@ -46,6 +67,45 @@ if SimpleCov.usable?
       expect(SimpleCov::ArrayFilter.new(["sample.rb", "other_file.rb"])).to be_matches subject
     end
 
+    it "doesn't match a parent directory with a new SimpleCov::ArrayFilter" do
+      parent_dir_name = File.basename(File.expand_path("..", File.dirname(__FILE__)))
+      expect(SimpleCov::ArrayFilter.new([parent_dir_name])).not_to be_matches subject
+    end
+
+    it "matches a new SimpleCov::ArrayFilter when /sample.rb/ is passed as array" do
+      expect(SimpleCov::ArrayFilter.new([/sample.rb/])).to be_matches subject
+    end
+
+    it "doesn't match a new SimpleCov::ArrayFilter when a file path different than /sample.rb/ is passed as array" do
+      expect(SimpleCov::ArrayFilter.new([/other_file.rb/])).not_to be_matches subject
+    end
+
+    it "matches a new SimpleCov::ArrayFilter when a block is passed as array and returns true" do
+      expect(SimpleCov::ArrayFilter.new([proc { true }])).to be_matches subject
+    end
+
+    it "doesn't match a new SimpleCov::ArrayFilter when a block that returns false is passed as array" do
+      expect(SimpleCov::ArrayFilter.new([proc { false }])).not_to be_matches subject
+    end
+
+    it "matches a new SimpleCov::ArrayFilter when a custom class that returns true is passed as array" do
+      filter = Class.new(SimpleCov::Filter) do
+        def matches?(_)
+          true
+        end
+      end.new(nil)
+      expect(SimpleCov::ArrayFilter.new([filter])).to be_matches subject
+    end
+
+    it "doesn't match a new SimpleCov::ArrayFilter when a custom class that returns false is passed as array" do
+      filter = Class.new(SimpleCov::Filter) do
+        def matches?(_)
+          false
+        end
+      end.new(nil)
+      expect(SimpleCov::ArrayFilter.new([filter])).not_to be_matches subject
+    end
+
     context "with no filters set up and a basic source file in an array" do
       before do
         @prev_filters = SimpleCov.filters
@@ -94,5 +154,49 @@ if SimpleCov.usable?
         expect(SimpleCov.filtered(subject)).to be_a SimpleCov::FileList
       end
     end
+
+    context "with the default configuration" do
+      skip "requires the default configuration" if ENV["SIMPLECOV_NO_DEFAULTS"]
+
+      def a_file(path)
+        path = File.join(SimpleCov.root, path) unless path.start_with?("/")
+        SimpleCov::SourceFile.new(path, [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil])
+      end
+
+      context "inside the project" do
+        it "doesn't filter" do
+          expect(SimpleCov.filtered([a_file("foo.rb")]).count).to eq(1)
+        end
+
+        it "filters vendor/bundle" do
+          expect(SimpleCov.filtered([a_file("vendor/bundle/foo.rb")]).count).to eq(0)
+        end
+      end
+
+      context "outside the project" do
+        it "filters" do
+          expect(SimpleCov.filtered([a_file("/other/path/foo.rb")]).count).to eq(0)
+        end
+
+        it "filters even if the sibling directory has SimpleCov.root as a prefix" do
+          sibling_dir = SimpleCov.root + "_cache"
+          expect(SimpleCov.filtered([a_file(sibling_dir + "/foo.rb")]).count).to eq(0)
+        end
+      end
+    end
+
+    describe ".class_for_argument" do
+      it "returns SimpleCov::StringFilter for a string" do
+        expect(SimpleCov::Filter.class_for_argument("filestring")).to eq(SimpleCov::StringFilter)
+      end
+
+      it "returns SimpleCov::RegexFilter for a string" do
+        expect(SimpleCov::Filter.class_for_argument(/regex/)).to eq(SimpleCov::RegexFilter)
+      end
+
+      it "returns SimpleCov::RegexFilter for a string" do
+        expect(SimpleCov::Filter.class_for_argument(%w[file1 file2])).to eq(SimpleCov::ArrayFilter)
+      end
+    end
   end
 end

data/spec/lines_classifier_spec.rb

@@ -0,0 +1,103 @@
+require "helper"
+require "simplecov/lines_classifier"
+
+describe SimpleCov::LinesClassifier do
+  describe "#classify" do
+    describe "relevant lines" do
+      it "determines code as relevant" do
+        classified_lines = subject.classify [
+          "module Foo",
+          "  class Baz",
+          "    def Bar",
+          "      puts 'hi'",
+          "    end",
+          "  end",
+          "end",
+        ]
+
+        expect(classified_lines.length).to eq 7
+        expect(classified_lines).to all be_relevant
+      end
+    end
+
+    describe "not-relevant lines" do
+      it "determines whitespace is not-relevant" do
+        classified_lines = subject.classify [
+          "",
+          "  ",
+          "\t\t",
+        ]
+
+        expect(classified_lines.length).to eq 3
+        expect(classified_lines).to all be_irrelevant
+      end
+
+      describe "comments" do
+        it "determines comments are not-relevant" do
+          classified_lines = subject.classify [
+            "#Comment",
+            " # Leading space comment",
+            "\t# Leading tab comment",
+          ]
+
+          expect(classified_lines.length).to eq 3
+          expect(classified_lines).to all be_irrelevant
+        end
+
+        it "doesn't mistake interpolation as a comment" do
+          classified_lines = subject.classify [
+            'puts "#{var}"',
+          ]
+
+          expect(classified_lines.length).to eq 1
+          expect(classified_lines).to all be_relevant
+        end
+      end
+
+      describe ":nocov: blocks" do
+        it "determines :nocov: blocks are not-relevant" do
+          classified_lines = subject.classify [
+            "# :nocov:",
+            "def hi",
+            "end",
+            "# :nocov:",
+          ]
+
+          expect(classified_lines.length).to eq 4
+          expect(classified_lines).to all be_irrelevant
+        end
+
+        it "determines all lines after a non-closing :nocov: as not-relevant" do
+          classified_lines = subject.classify [
+            "# :nocov:",
+            "puts 'Not relevant'",
+            "# :nocov:",
+            "puts 'Relevant again'",
+            "puts 'Still relevant'",
+            "# :nocov:",
+            "puts 'Not relevant till the end'",
+            "puts 'Ditto'",
+          ]
+
+          expect(classified_lines.length).to eq 8
+
+          expect(classified_lines[0..2]).to all be_irrelevant
+          expect(classified_lines[3..4]).to all be_relevant
+          expect(classified_lines[5..7]).to all be_irrelevant
+        end
+      end
+    end
+  end
+
+  RSpec::Matchers.define :be_relevant do
+    match do |actual|
+      actual == SimpleCov::LinesClassifier::RELEVANT
+    end
+  end
+
+  RSpec::Matchers.define :be_irrelevant do
+    match do |actual|
+      actual == SimpleCov::LinesClassifier::NOT_RELEVANT
+    end
+  end
+end

data/spec/result_merger_spec.rb

@@ -1,10 +1,16 @@
 require "helper"
+require "tempfile"
+require "timeout"
 
 if SimpleCov.usable?
   describe SimpleCov::ResultMerger do
+    before do
+      SimpleCov::ResultMerger.clear_resultset
+      File.delete(SimpleCov::ResultMerger.resultset_path) if File.exist?(SimpleCov::ResultMerger.resultset_path)
+    end
+
     describe "with two faked coverage resultsets" do
       before do
-        SimpleCov.use_merging true
         @resultset1 = {
           source_fixture("sample.rb") => [nil, 1, 1, 1, nil, nil, 1, 1, nil, nil],
           source_fixture("app/models/user.rb") => [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil],
@@ -56,7 +62,7 @@ if SimpleCov.usable?
           end
 
           it "returns a hash containing keys ['result1' and 'result2'] for resultset" do
-            expect(SimpleCov::ResultMerger.resultset.keys.sort).to eq %w(result1 result2)
+            expect(SimpleCov::ResultMerger.resultset.keys.sort).to eq %w[result1 result2]
           end
 
           it "returns proper values for merged_result" do
@@ -73,15 +79,92 @@ if SimpleCov.usable?
               expect(SimpleCov::ResultMerger.results.length).to eq(1)
             end
           end
+        end
+      end
+    end
+
+    describe ".store_result" do
+      it "refreshes the resultset" do
+        set = SimpleCov::ResultMerger.resultset
+        SimpleCov::ResultMerger.store_result({})
+        new_set = SimpleCov::ResultMerger.resultset
+        expect(new_set).not_to be(set)
+      end
 
-          context "with merging disabled" do
-            before { SimpleCov.use_merging false }
+      it "persists to disk" do
+        SimpleCov::ResultMerger.store_result("a" => [1])
+        SimpleCov::ResultMerger.clear_resultset
+        new_set = SimpleCov::ResultMerger.resultset
+        expect(new_set).to eq("a" => [1])
+      end
+
+      it "synchronizes writes" do
+        expect(SimpleCov::ResultMerger).to receive(:synchronize_resultset)
+        SimpleCov::ResultMerger.store_result({})
+      end
+    end
 
-            it "returns nil for SimpleCov.result" do
-              expect(SimpleCov.result).to be_nil
+    describe ".resultset" do
+      it "caches" do
+        set = SimpleCov::ResultMerger.resultset
+        new_set = SimpleCov::ResultMerger.resultset
+        expect(new_set).to be(set)
+      end
+
+      it "synchronizes reads" do
+        expect(SimpleCov::ResultMerger).to receive(:synchronize_resultset)
+        SimpleCov::ResultMerger.resultset
+      end
+    end
+
+    describe ".synchronize_resultset" do
+      it "is reentrant (i.e. doesn't block its own process)" do
+        # without @resultset_locked, this spec would fail and
+        # `.store_result` wouldn't work
+        expect do
+          Timeout.timeout(1) do
+            SimpleCov::ResultMerger.synchronize_resultset do
+              SimpleCov::ResultMerger.synchronize_resultset do
+              end
             end
           end
+        end.not_to raise_error
+      end
+
+      it "blocks other processes" do
+        file = Tempfile.new("foo")
+
+        other_process = open("|ruby -e " + Shellwords.escape(<<-CODE) + " 2>/dev/null")
+          require "simplecov"
+          SimpleCov.coverage_dir(#{SimpleCov.coverage_dir.inspect})
+
+          # ensure the parent process has enough time to get a
+          # lock before we do
+          sleep 0.5
+
+          $stdout.sync = true
+          puts "running" # see `sleep`s in parent process
+
+          SimpleCov::ResultMerger.synchronize_resultset do
+            File.open(#{file.path.inspect}, "a") { |f| f.write("process 2\n") }
+          end
+        CODE
+
+        SimpleCov::ResultMerger.synchronize_resultset do
+          # wait until the child process is going, and then wait some more
+          # so we can be sure it blocks on the lock we already have.
+          sleep 0.1 until other_process.gets == "running\n"
+          sleep 1
+
+          # despite the sleeps, this will be written first since we got
+          # the first lock
+          File.open(file.path, "a") { |f| f.write("process 1\n") }
         end
+
+        # wait for it to finish
+        other_process.gets
+
+        expect(file.read).to eq("process 1\nprocess 2\n")
       end
     end
   end