simplecov 0.14.1 → 0.15.0

data/lib/simplecov/defaults.rb

@@ -7,7 +7,7 @@ SimpleCov.profiles.define "root_filter" do
   root_filter = nil
   add_filter do |src|
     root_filter ||= /\A#{Regexp.escape(SimpleCov.root)}/io
-    !(src.filename =~ root_filter)
+    src.filename !~ root_filter
   end
 end
 
@@ -25,15 +25,15 @@ end
 SimpleCov.profiles.define "rails" do
   load_profile "test_frameworks"
 
-  add_filter "/config/"
-  add_filter "/db/"
+  add_filter %r{^/config/}
+  add_filter %r{/^/db/}
 
   add_group "Controllers", "app/controllers"
   add_group "Channels", "app/channels" if defined?(ActionCable)
   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 "Jobs", %w[app/jobs app/workers]
   add_group "Libraries", "lib"
 
   track_files "{app,lib}/**/*.rb"

data/lib/simplecov/file_list.rb

@@ -5,25 +5,25 @@ module SimpleCov
     # Returns the count of lines that have coverage
     def covered_lines
       return 0.0 if empty?
-      map { |f| f.covered_lines.count }.inject(&:+)
+      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(&:+)
+      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(&:+)
+      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(&:+)
+      map { |f| f.skipped_lines.count }.inject(:+)
     end
 
     # Computes the coverage based upon lines covered and lines missed for each file
@@ -53,7 +53,7 @@ module SimpleCov
     # @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)
+      Float(map { |f| f.covered_strength * f.lines_of_code }.inject(:+) / lines_of_code)
     end
   end
 end

data/lib/simplecov/filter.rb

@@ -24,13 +24,40 @@ module SimpleCov
       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 =~ /#{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
 
@@ -43,11 +70,19 @@ module SimpleCov
   end
 
   class ArrayFilter < SimpleCov::Filter
-    # Returns true if any of the file paths passed in the given array matches the string
-    # configured when initializing this Filter with StringFilter.new(['some/path', 'other/path'])
+    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|
-        source_files_list.filename =~ /#{arg}/
+        arg.matches?(source_files_list)
       end
     end
   end

data/lib/simplecov/formatter/simple_formatter.rb

@@ -6,7 +6,7 @@ module SimpleCov
     class SimpleFormatter
       # Takes a SimpleCov::Result and generates a string out of it
       def format(result)
-        output = ""
+        output = "".dup
         result.groups.each do |name, files|
           output << "Group: #{name}\n"
           output << "=" * 40

data/lib/simplecov/lines_classifier.rb

@@ -0,0 +1,32 @@
+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}\:)/
+    end
+
+    def classify(lines)
+      skipping = false
+
+      lines.map do |line|
+        if line =~ self.class.no_cov_line
+          skipping = !skipping
+          NOT_RELEVANT
+        elsif skipping || line =~ WHITESPACE_OR_COMMENT_LINE
+          NOT_RELEVANT
+        else
+          RELEVANT
+        end
+      end
+    end
+  end
+end

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.0".freeze
 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,19 @@ if SimpleCov.usable?
         expect(SimpleCov.filtered(subject)).to be_a SimpleCov::FileList
       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