simplecov 0.11.1 → 0.13.0

data/lib/simplecov.rb

@@ -2,13 +2,18 @@
 # Code coverage for ruby 1.9. Please check out README for a full introduction.
 #
 # Coverage may be inaccurate under JRUBY.
-if defined?(JRUBY_VERSION)
-  if ENV["JRUBY_OPTS"].to_s !~ /-Xcli.debug=true/
-    warn "Coverage may be inaccurate; Try setting JRUBY_OPTS=\"-Xcli.debug=true --debug\""
-    # see https://github.com/metricfu/metric_fu/pull/226
-    #     https://github.com/jruby/jruby/issues/1196
-    #     https://jira.codehaus.org/browse/JRUBY-6106
-    #     https://github.com/colszowka/simplecov/issues/86
+if defined?(JRUBY_VERSION) && defined?(JRuby)
+
+  # @see https://github.com/jruby/jruby/issues/1196
+  # @see https://github.com/metricfu/metric_fu/pull/226
+  # @see https://github.com/colszowka/simplecov/issues/420
+  # @see https://github.com/colszowka/simplecov/issues/86
+  # @see https://jira.codehaus.org/browse/JRUBY-6106
+
+  unless org.jruby.RubyInstanceConfig.FULL_TRACE_ENABLED
+    warn 'Coverage may be inaccurate; set the "--debug" command line option,' \
+      ' or do JRUBY_OPTS="--debug"' \
+      ' or set the "debug.fullTrace=true" option in your .jrubyrc'
   end
 end
 module SimpleCov
@@ -53,9 +58,9 @@ module SimpleCov
     # their coverage to zero.
     #
     def add_not_loaded_files(result)
-      if @track_files_glob
+      if track_files
         result = result.dup
-        Dir[@track_files_glob].each do |file|
+        Dir[track_files].each do |file|
           absolute = File.expand_path(file)
 
           result[absolute] ||= [0] * File.foreach(absolute).count
@@ -70,14 +75,22 @@ module SimpleCov
     # from cache using SimpleCov::ResultMerger if use_merging is activated (default)
     #
     def result
-      @result ||= SimpleCov::Result.new(add_not_loaded_files(Coverage.result)) if running
+      # Ensure the variable is defined to avoid ruby warnings
+      @result = nil unless defined?(@result)
+
+      # Collect our coverage result
+      if running && !result?
+        @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
       if use_merging
-        SimpleCov::ResultMerger.store_result(@result) if @result
-        return SimpleCov::ResultMerger.merged_result
+        SimpleCov::ResultMerger.store_result(@result) if result?
+
+        SimpleCov::ResultMerger.merged_result
       else
-        return @result if defined? @result
+        @result
       end
     ensure
       self.running = false
@@ -112,7 +125,7 @@ module SimpleCov
         grouped[name] = SimpleCov::FileList.new(files.select { |source_file| filter.matches?(source_file) })
         grouped_files += grouped[name]
       end
-      if groups.length > 0 && (other_files = files.reject { |source_file| grouped_files.include?(source_file) }).length > 0
+      if !groups.empty? && !(other_files = files.reject { |source_file| grouped_files.include?(source_file) }).empty?
         grouped["Ungrouped"] = SimpleCov::FileList.new(other_files)
       end
       grouped

data/simplecov.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |gem|
 
   gem.required_ruby_version = ">= 1.8.7"
 
-  gem.add_dependency "json", "~> 1.8"
+  gem.add_dependency "json", ">= 1.8", "< 3"
   gem.add_dependency "simplecov-html", "~> 0.10.0"
   gem.add_dependency "docile", "~> 1.1.0"
 

data/spec/1_8_fallbacks_spec.rb

@@ -6,24 +6,26 @@ require "helper"
 # TODO: This should be expanded upon all methods that could potentially
 # be called in a test/spec-helper simplecov config block
 #
-describe "Ruby 1.8 fallback" do
-  it "return false when calling SimpleCov.start" do
-    expect(SimpleCov.start).to be false
-  end
+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 { fail "Shouldn't reach this!" }).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 { fail "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
+    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 if RUBY_VERSION.start_with? "1.8"
+end

data/spec/command_guesser_spec.rb

@@ -1,46 +1,48 @@
 require "helper"
 
-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
+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 "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 "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 "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 '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")
+    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 if SimpleCov.usable?
+end

data/spec/faked_project/lib/faked_project/some_class.rb

@@ -14,7 +14,7 @@ class SomeClass
     if item == label
       return true
     else
-      fail "Item does not match label"
+      raise "Item does not match label"
     end
   rescue
     false

data/spec/faked_project/spec/forking_spec.rb

@@ -2,6 +2,7 @@ require "spec_helper"
 
 describe "forking" do
   it do
-    Process.waitpid(Kernel.fork {})
+    # TODO: The defined?(RUBY_ENGINE) check can be dropped for simplecov 1.0.0
+    Process.waitpid(Kernel.fork {}) unless defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
   end
 end

data/spec/file_list_spec.rb

@@ -1,48 +1,50 @@
 require "helper"
 
-describe SimpleCov::Result do
-  subject do
-    original_result = {
-      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],
-      source_fixture("app/controllers/sample_controller.rb") => [nil, 2, 2, 0, nil, nil, 0, nil, nil, nil],
-    }
-    SimpleCov::Result.new(original_result).files
-  end
-
-  it "has 11 covered lines" do
-    expect(subject.covered_lines).to eq(11)
-  end
-
-  it "has 3 missed lines" do
-    expect(subject.missed_lines).to eq(3)
-  end
-
-  it "has 19 never lines" do
-    expect(subject.never_lines).to eq(19)
-  end
-
-  it "has 14 lines of code" do
-    expect(subject.lines_of_code).to eq(14)
-  end
-
-  it "has 3 skipped lines" do
-    expect(subject.skipped_lines).to eq(3)
-  end
-
-  it "has the correct covered percent" do
-    expect(subject.covered_percent).to eq(78.57142857142857)
-  end
-
-  it "has the correct covered percentages" do
-    expect(subject.covered_percentages).to eq([50.0, 80.0, 100.0])
-  end
-
-  it "has the correct least covered file" do
-    expect(subject.least_covered_file).to match(/sample_controller.rb/)
-  end
-
-  it "has the correct covered strength" do
-    expect(subject.covered_strength).to eq(0.9285714285714286)
-  end
-end if SimpleCov.usable?
+if SimpleCov.usable?
+  describe SimpleCov::Result do
+    subject do
+      original_result = {
+        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],
+        source_fixture("app/controllers/sample_controller.rb") => [nil, 2, 2, 0, nil, nil, 0, nil, nil, nil],
+      }
+      SimpleCov::Result.new(original_result).files
+    end
+
+    it "has 11 covered lines" do
+      expect(subject.covered_lines).to eq(11)
+    end
+
+    it "has 3 missed lines" do
+      expect(subject.missed_lines).to eq(3)
+    end
+
+    it "has 19 never lines" do
+      expect(subject.never_lines).to eq(19)
+    end
+
+    it "has 14 lines of code" do
+      expect(subject.lines_of_code).to eq(14)
+    end
+
+    it "has 3 skipped lines" do
+      expect(subject.skipped_lines).to eq(3)
+    end
+
+    it "has the correct covered percent" do
+      expect(subject.covered_percent).to eq(78.57142857142857)
+    end
+
+    it "has the correct covered percentages" do
+      expect(subject.covered_percentages).to eq([50.0, 80.0, 100.0])
+    end
+
+    it "has the correct least covered file" do
+      expect(subject.least_covered_file).to match(/sample_controller.rb/)
+    end
+
+    it "has the correct covered strength" do
+      expect(subject.covered_strength).to eq(0.9285714285714286)
+    end
+  end
+end

data/spec/filters_spec.rb

@@ -1,96 +1,98 @@
 require "helper"
 
-describe SimpleCov::SourceFile do
-  subject do
-    SimpleCov::SourceFile.new(source_fixture("sample.rb"), [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil])
-  end
-
-  it "doesn't match a new SimpleCov::StringFilter 'foobar'" do
-    expect(SimpleCov::StringFilter.new("foobar")).not_to be_matches subject
-  end
-
-  it "doesn't match a new SimpleCov::StringFilter 'some/path'" do
-    expect(SimpleCov::StringFilter.new("some/path")).not_to be_matches subject
-  end
-
-  it "matches a new SimpleCov::StringFilter 'spec/fixtures'" do
-    expect(SimpleCov::StringFilter.new("spec/fixtures")).to be_matches subject
-  end
-
-  it "matches a new SimpleCov::StringFilter 'spec/fixtures/sample.rb'" do
-    expect(SimpleCov::StringFilter.new("spec/fixtures/sample.rb")).to be_matches subject
-  end
-
-  it "matches a new SimpleCov::StringFilter 'sample.rb'" do
-    expect(SimpleCov::StringFilter.new("sample.rb")).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
+if SimpleCov.usable?
+  describe SimpleCov::SourceFile do
+    subject do
+      SimpleCov::SourceFile.new(source_fixture("sample.rb"), [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil])
+    end
 
-  it "matches a new SimpleCov::BlockFilter that is applicable" do
-    expect(SimpleCov::BlockFilter.new(proc { |s| File.basename(s.filename) == "sample.rb" })).to be_matches subject
-  end
+    it "doesn't match a new SimpleCov::StringFilter 'foobar'" do
+      expect(SimpleCov::StringFilter.new("foobar")).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::StringFilter 'some/path'" do
+      expect(SimpleCov::StringFilter.new("some/path")).not_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::StringFilter 'spec/fixtures'" do
+      expect(SimpleCov::StringFilter.new("spec/fixtures")).to be_matches subject
+    end
 
-  it "matches a new SimpleCov::ArrayFilter when two file paths including 'sample.rb' are passed as array" do
-    expect(SimpleCov::ArrayFilter.new(["sample.rb", "other_file.rb"])).to be_matches subject
-  end
+    it "matches a new SimpleCov::StringFilter 'spec/fixtures/sample.rb'" do
+      expect(SimpleCov::StringFilter.new("spec/fixtures/sample.rb")).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
-      SimpleCov.filters = []
+    it "matches a new SimpleCov::StringFilter 'sample.rb'" do
+      expect(SimpleCov::StringFilter.new("sample.rb")).to be_matches subject
     end
 
-    subject do
-      [SimpleCov::SourceFile.new(source_fixture("sample.rb"), [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil])]
+    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
 
-    after do
-      SimpleCov.filters = @prev_filters
+    it "matches a new SimpleCov::BlockFilter that is applicable" do
+      expect(SimpleCov::BlockFilter.new(proc { |s| File.basename(s.filename) == "sample.rb" })).to be_matches subject
     end
 
-    it 'returns 0 items after executing SimpleCov.filtered on files when using a "sample" string filter' do
-      SimpleCov.add_filter "sample"
-      expect(SimpleCov.filtered(subject).count).to be_zero
+    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 'returns 0 items after executing SimpleCov.filtered on files when using a "spec/fixtures" string filter' do
-      SimpleCov.add_filter "spec/fixtures"
-      expect(SimpleCov.filtered(subject).count).to be_zero
+    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 'returns 1 item after executing SimpleCov.filtered on files when using a "fooo" string filter' do
-      SimpleCov.add_filter "fooo"
-      expect(SimpleCov.filtered(subject).count).to eq(1)
+    it "matches a new SimpleCov::ArrayFilter when two file paths including 'sample.rb' are passed as array" do
+      expect(SimpleCov::ArrayFilter.new(["sample.rb", "other_file.rb"])).to be_matches subject
     end
 
-    it "returns 0 items after executing SimpleCov.filtered on files when using a block filter that returns true" do
-      SimpleCov.add_filter do
-        true
+    context "with no filters set up and a basic source file in an array" do
+      before do
+        @prev_filters = SimpleCov.filters
+        SimpleCov.filters = []
       end
-      expect(SimpleCov.filtered(subject).count).to be_zero
-    end
 
-    it "returns 1 item after executing SimpleCov.filtered on files when using an always-false block filter" do
-      SimpleCov.add_filter do
-        false
+      subject do
+        [SimpleCov::SourceFile.new(source_fixture("sample.rb"), [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil])]
+      end
+
+      after do
+        SimpleCov.filters = @prev_filters
+      end
+
+      it 'returns 0 items after executing SimpleCov.filtered on files when using a "sample" string filter' do
+        SimpleCov.add_filter "sample"
+        expect(SimpleCov.filtered(subject).count).to be_zero
       end
-      expect(SimpleCov.filtered(subject).count).to eq(1)
-    end
 
-    it "returns a FileList after filtering" do
-      SimpleCov.add_filter "fooo"
-      expect(SimpleCov.filtered(subject)).to be_a SimpleCov::FileList
+      it 'returns 0 items after executing SimpleCov.filtered on files when using a "spec/fixtures" string filter' do
+        SimpleCov.add_filter "spec/fixtures"
+        expect(SimpleCov.filtered(subject).count).to be_zero
+      end
+
+      it 'returns 1 item after executing SimpleCov.filtered on files when using a "fooo" string filter' do
+        SimpleCov.add_filter "fooo"
+        expect(SimpleCov.filtered(subject).count).to eq(1)
+      end
+
+      it "returns 0 items after executing SimpleCov.filtered on files when using a block filter that returns true" do
+        SimpleCov.add_filter do
+          true
+        end
+        expect(SimpleCov.filtered(subject).count).to be_zero
+      end
+
+      it "returns 1 item after executing SimpleCov.filtered on files when using an always-false block filter" do
+        SimpleCov.add_filter do
+          false
+        end
+        expect(SimpleCov.filtered(subject).count).to eq(1)
+      end
+
+      it "returns a FileList after filtering" do
+        SimpleCov.add_filter "fooo"
+        expect(SimpleCov.filtered(subject)).to be_a SimpleCov::FileList
+      end
     end
   end
-end if SimpleCov.usable?
+end

data/spec/fixtures/deleted_source_sample.rb

@@ -12,4 +12,4 @@ code = %{
 File.open(file, "w") { |f| f.print code }
 load file
 File.unlink file
-fail unless kill_the_buddha(3) == 27
+raise unless kill_the_buddha(3) == 27