simplecov 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 15fa4589e25ee4710bdbcec7485a4d8ec7be7abb
-  data.tar.gz: a1627cf287ce3c70ba2d60e0943f28f90fcdef79
+  metadata.gz: 8e97e7dcf1f3c003a18fe662722aa6afb4c22a4f
+  data.tar.gz: 53416d84e2f00e0d4b9da2a9ffd8f92f01eaf084
 SHA512:
-  metadata.gz: 03a052dcae5923fe19e56f6f20fbd390505f03dca386d51eaca4b525252054856ce492e783e6923ad3b89a46719b89556747b8bbac295513b1d245fba3232e79
-  data.tar.gz: e2cd84b984e35dfa0c048f375ed2555f08d4df239d616d7c70289b086b1904394b1344f177ad5d7dd08cfb695fe2c22d5375af8e07da5d773500b034d87d4b1c
+  metadata.gz: 5553c580dc83af525bde5a86cba9648a0bb61a5340d5047f17aaf0c933375a4594b5b0094321374e3215d2dd617717e9d5aa0b8c27fe9a2937b06cf2eb757700
+  data.tar.gz: 290a8fd21178bbb5cf125a8b06d3ac844cc886c56bda739bb3056166b760afef308c1504cdde5277cc7ebfb877abbb505353b71bf0f9be3b9b2dfc9977cce580

data/.travis.yml

@@ -20,13 +20,10 @@ rvm:
   - 2.4.0
   - ruby-head
   - jruby-head
-  - jruby-9.1.7.0
-  - rbx-2
+  - jruby-9.1.8.0
 
 matrix:
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-head
-    - rvm: jruby-9.1.7.0
-    - rvm: rbx-2
   fast_finish: true

data/CHANGELOG.md

@@ -1,10 +1,27 @@
-0.13.0 2016-01-25 ([changes](https://github.com/colszowka/simplecov/compare/v0.12.0...v0.13.0))
+0.14.0 2017-03-15 ([changes](https://github.com/colszowka/simplecov/compare/v0.13.0...v0.14.0))
+==========
+
+## Enhancements
+
+* Officially support JRuby 9.1+ going forward (should also work with previous releases). See [#547](https://github.com/colszowka/simplecov/pull/547) (ping @PragTob when encountering issues)
+* Add Channel group to Rails profile, when `ActionCable` is loaded. See [#492](https://github.com/colszowka/simplecov/pull/492) (thanks @BenMorganIO)
+* Stop `extend`ing instances of `Array` and `Hash` during merging results avoiding problems frozen results while manually merging results. See [#558](https://github.com/colszowka/simplecov/pull/558) (thanks @aroben)
+
+## Bugfixes
+
+* Fix parallel_tests when a thread ends up running no tests. See [#533](https://github.com/colszowka/simplecov/pull/533) (thanks @cshaffer)
+* Skip the `:nocov:` comments along with the code that they skip. See [#551](https://github.com/colszowka/simplecov/pull/551) (thanks @ebiven)
+* Fix crash when Home environment variable is unset. See [#482](https://github.com/colszowka/simplecov/pull/482) (thanks @waldyr)
+* Make track_files work again when explicitly setting it to nil. See [#463](https://github.com/colszowka/simplecov/pull/463) (thanks @craiglittle)
+* Do not overwrite .last_run.json file when refuse_coverage_drop option is enabled and the coverage has dropped (lead to you being able to just rerun tests and everything was _fine_). See [#553](https://github.com/colszowka/simplecov/pull/553) (thanks @Miloshes)
+
+0.13.0 2017-01-25 ([changes](https://github.com/colszowka/simplecov/compare/v0.12.0...v0.13.0))
 ==========
 
 ## Enhancements
 
 * Faster run times when a very large number of files is loaded into SimpleCov. See [#520](https://github.com/colszowka/simplecov/pull/520) (thanks @alyssais)
-* Only read in source code files that are actually used (faster when files are ignored etc.). See [#540](https://github.com/colszowka/simplecov/pull/540) (tahks @yui-knk)
+* Only read in source code files that are actually used (faster when files are ignored etc.). See [#540](https://github.com/colszowka/simplecov/pull/540) (thanks @yui-knk)
 
 ## Bugfixes
 

data/Gemfile

@@ -27,7 +27,7 @@ group :test do
     gem "capybara"
     gem "nokogiri", RUBY_VERSION < "2.1" ? "~> 1.6.0" : ">= 1.7"
     gem "cucumber"
-    gem "phantomjs", "~> 1.9"
+    gem "phantomjs", "~> 2.1"
     gem "poltergeist"
     gem "rubocop" unless RUBY_VERSION.start_with?("1.")
     gem "test-unit"

data/README.md

@@ -66,11 +66,12 @@ Getting started
     code is required!**
 
     SimpleCov must be running in the process that you want the code coverage
-    analysis to happen on. When testing a server process (i.e. a JSON API
-    endpoint) via a separate test process (i.e. when using Selenium) where you
+    analysis to happen on. When testing a server process (e.g. a JSON API
+    endpoint) via a separate test process (e.g. when using Selenium) where you
     want to see all code executed by the `rails server`, and not just code
     executed in your actual test files, you'll want to add something like this
-    to the top of `script/rails` (or `bin/rails` for Rails 4):
+    to the top of `script/rails` (or `bin/rails` for Rails 4), but below the
+    "shebang" line (`#! /usr/bin/env ruby`):
 
     ```ruby
     if ENV['RAILS_ENV'] == 'test'
@@ -79,6 +80,7 @@ Getting started
       puts "required simplecov"
     end
     ```
+
 3. Run your tests, open up `coverage/index.html` in your browser and check out
    what you've missed so far.
 4. Add the following to your `.gitignore` file to ensure that coverage results
@@ -229,7 +231,7 @@ Please check out the [Configuration] API documentation to find out what you can
 
 ## Using .simplecov for centralized config
 
-If you use SimpleCov to merge multiple test suite results (i.e. Test/Unit and Cucumber) into a single report, you'd normally have to
+If you use SimpleCov to merge multiple test suite results (e.g. Test/Unit and Cucumber) into a single report, you'd normally have to
 set up all your config options twice, once in `test_helper.rb` and once in `env.rb`.
 
 To avoid this, you can place a file called `.simplecov` in your project root. You can then just leave the `require 'simplecov'` in each
@@ -432,7 +434,7 @@ You can deactivate merging altogether with `SimpleCov.use_merging false`.
 
 ## Running coverage only on demand
 
-The Ruby STDLIB Coverage library that SimpleCov builds upon is *very* fast (i.e. on a ~10 min Rails test suite, the speed drop was
+The Ruby STDLIB Coverage library that SimpleCov builds upon is *very* fast (on a ~10 min Rails test suite, the speed drop was
 only a couple seconds for me), and therefore it's SimpleCov's policy to just generate coverage every time you run your tests because
 it doesn't do your test speed any harm and you're always equipped with the latest and greatest coverage results.
 
@@ -582,14 +584,11 @@ SimpleCov.formatters = [
 
 ## Ruby version compatibility
 
-Only Ruby 1.9+ ships with the coverage library that SimpleCov depends upon.
-SimpleCov is built against various other Rubies, including Rubinius and JRuby,
-in [Continuous Integration], but this happens only to ensure that SimpleCov
-does not make your test suite crash right now. Whether SimpleCov will support
-JRuby/Rubinius in the future depends solely on whether those Ruby interpreters
-add the coverage library.
+Only Ruby 1.9+ ships with the coverage library that SimpleCov depends upon and that's what SimpleCov supports. Additionally JRuby 9.1+ is supported as well, while JRuby 1.7 and 9.0 should work they're not "officially" supported.
+SimpleCov is also built against Ruby 1.8 in [Continuous Integration], but this happens only to ensure that SimpleCov
+does not make your test suite crash right now.
 
-SimpleCov is built in [Continuous Integration] on Ruby 1.9.3, 2.0.0, 2.1, and 2.2.
+SimpleCov is built in [Continuous Integration] on Ruby 1.9.3, 2.0.0, 2.1, 2.2, 2.3, 2.4 as well as JRuby 9.1.
 
 ## Want to find dead code in production?
 
@@ -599,12 +598,18 @@ Try [Coverband](https://github.com/danmayer/coverband).
 
 If you're using [Spring](https://github.com/rails/spring) to speed up test suite runs and want to run SimpleCov along with them, you'll find that it often misreports coverage with the default config due to some sort of eager loading issue. Don't despair!
 
-1. Change the following settings in `development.rb` and `test.rb`.
+1. Change the following settings in `test.rb`.
 
     ```ruby
+    # For Rails 4 or earlier, use the following configuration:
     # Disable Rails's static asset server (Apache or nginx will already do this)
     config.serve_static_files = false
     config.eager_load = false
+
+    # For Rails 5, use the following configuration:
+    # Disable Rails's static asset server (Apache or nginx will already do this)
+    config.public_file_server.enabled = false
+    config.eager_load = false
     ```
 2. Add your SimpleCov config, as you normally would, to your `spec_helper.rb`
    (or `rails_helper.rb` for RSpec 3). If you have a `config/spring.rb` file

data/Rakefile

@@ -36,6 +36,6 @@ else
   if RUBY_VERSION.start_with? "1.9"
     task :default => [:spec, :cucumber]
   else
-    task :default => [:spec, :cucumber, :rubocop]
+    task :default => [:rubocop, :spec, :cucumber]
   end
 end

data/features/config_nocov_token.feature

@@ -36,7 +36,7 @@ Feature:
       | lib/faked_project/meta_magic.rb         | 100.0 %  |
       | lib/faked_project/nocov.rb              | 100.0 %  |
 
-    And there should be 5 skipped lines in the source files
+    And there should be 7 skipped lines in the source files
 
     And the report should be based upon:
       | Unit Tests |
@@ -73,7 +73,7 @@ Feature:
       | lib/faked_project/meta_magic.rb         | 100.0 %  |
       | lib/faked_project/nocov.rb              | 100.0 %  |
 
-    And there should be 5 skipped lines in the source files
+    And there should be 7 skipped lines in the source files
 
     And the report should be based upon:
       | Unit Tests |

data/features/maximum_coverage_drop.feature

@@ -4,7 +4,7 @@ Feature:
   Exit code should be non-zero if the overall coverage decreases by more than
   the maximum_coverage_drop threshold.
 
-  Scenario:
+  Scenario: maximum_coverage_drop configured cam cause spec failure
     Given SimpleCov for Test/Unit is configured with:
       """
       require 'simplecov'
@@ -33,4 +33,57 @@ Feature:
     Then the exit status should not be 0
     And the output should contain "Coverage has dropped by 3.32% since the last time (maximum allowed: 3.14%)."
     And a file named "coverage/.last_run.json" should exist
+    And the file "coverage/.last_run.json" should contain:
+      """
+      {
+        "result": {
+          "covered_percent": 88.1
+        }
+      }
+      """
+
+  Scenario: maximum_coverage_drop not configured updates resultset
+    Given SimpleCov for Test/Unit is configured with:
+      """
+      require 'simplecov'
+      SimpleCov.start do
+        add_filter 'test.rb'
+      end
+      """
+
+    When I run `bundle exec rake test`
+    Then the exit status should be 0
+    And a file named "coverage/.last_run.json" should exist
+    And the file "coverage/.last_run.json" should contain:
+      """
+      {
+        "result": {
+          "covered_percent": 88.1
+        }
+      }
+      """
+
+    Given a file named "lib/faked_project/missed.rb" with:
+      """
+      class UncoveredSourceCode
+        def foo
+          never_reached
+        rescue => err
+          but no one cares about invalid ruby here
+        end
+      end
+      """
+
+    When I run `bundle exec rake test`
+    Then the exit status should be 0
+    And a file named "coverage/.last_run.json" should exist
+    And the file "coverage/.last_run.json" should contain:
+      """
+      {
+        "result": {
+          "covered_percent": 84.78
+        }
+      }
+      """
+
 

data/features/refuse_coverage_drop.feature

@@ -2,8 +2,9 @@
 Feature:
 
   Exit code should be non-zero if the overall coverage decreases.
+  And last_run file should not be overwritten with new coverage value.
 
-  Scenario:
+  Scenario: refuse_coverage_drop configured
     Given SimpleCov for Test/Unit is configured with:
       """
       require 'simplecov'
@@ -16,6 +17,14 @@ Feature:
     When I run `bundle exec rake test`
     Then the exit status should be 0
     And a file named "coverage/.last_run.json" should exist
+    And the file "coverage/.last_run.json" should contain:
+      """
+      {
+        "result": {
+          "covered_percent": 88.1
+        }
+      }
+      """
 
     Given a file named "lib/faked_project/missed.rb" with:
       """
@@ -32,4 +41,55 @@ Feature:
     Then the exit status should not be 0
     And the output should contain "Coverage has dropped by 3.32% since the last time (maximum allowed: 0.00%)."
     And a file named "coverage/.last_run.json" should exist
+    And the file "coverage/.last_run.json" should contain:
+      """
+      {
+        "result": {
+          "covered_percent": 88.1
+        }
+      }
+      """
+
+  Scenario: refuse_coverage_drop not configured updates resultset
+    Given SimpleCov for Test/Unit is configured with:
+      """
+      require 'simplecov'
+      SimpleCov.start do
+        add_filter 'test.rb'
+      end
+      """
+
+    When I run `bundle exec rake test`
+    Then the exit status should be 0
+    And a file named "coverage/.last_run.json" should exist
+    And the file "coverage/.last_run.json" should contain:
+      """
+      {
+        "result": {
+          "covered_percent": 88.1
+        }
+      }
+      """
 
+    Given a file named "lib/faked_project/missed.rb" with:
+      """
+      class UncoveredSourceCode
+        def foo
+          never_reached
+        rescue => err
+          but no one cares about invalid ruby here
+        end
+      end
+      """
+
+    When I run `bundle exec rake test`
+    Then the exit status should be 0
+    And a file named "coverage/.last_run.json" should exist
+    And the file "coverage/.last_run.json" should contain:
+      """
+      {
+        "result": {
+          "covered_percent": 84.78
+        }
+      }
+      """

data/features/skipping_code_blocks_manually.feature

@@ -35,7 +35,7 @@ Feature:
       | lib/faked_project/meta_magic.rb         | 100.0 %  |
       | lib/faked_project/nocov.rb              | 100.0 %  |
 
-    And there should be 5 skipped lines in the source files
+    And there should be 7 skipped lines in the source files
 
     And the report should be based upon:
       | Unit Tests |
@@ -64,7 +64,7 @@ Feature:
       | lib/faked_project/meta_magic.rb         | 100.0 %  |
       | lib/faked_project/nocov.rb              | 100.0 %  |
 
-    And there should be 5 skipped lines in the source files
+    And there should be 7 skipped lines in the source files
 
     And the report should be based upon:
       | Unit Tests |

data/features/step_definitions/simplecov_steps.rb

@@ -61,7 +61,7 @@ Then /^the report should be based upon:$/ do |table|
     )
 end
 
-# This is neccessary to ensure timing-dependant tests like the merge timeout
+# This is necessary to ensure timing-dependant tests like the merge timeout
 # do not fail on powerful machines.
 When /^I wait for (\d+) seconds$/ do |seconds|
   sleep seconds.to_i

data/lib/simplecov.rb

@@ -58,9 +58,9 @@ module SimpleCov
     # their coverage to zero.
     #
     def add_not_loaded_files(result)
-      if track_files
+      if tracked_files
         result = result.dup
-        Dir[track_files].each do |file|
+        Dir[tracked_files].each do |file|
           absolute = File.expand_path(file)
 
           result[absolute] ||= [0] * File.foreach(absolute).count
@@ -172,7 +172,7 @@ require "simplecov/result"
 require "simplecov/filter"
 require "simplecov/formatter"
 require "simplecov/last_run"
-require "simplecov/merge_helpers"
+require "simplecov/raw_coverage"
 require "simplecov/result_merger"
 require "simplecov/command_guesser"
 require "simplecov/version"

data/lib/simplecov/configuration.rb

@@ -50,9 +50,16 @@ module SimpleCov
     # or not they were explicitly required. Without this, un-required files
     # will not be present in the final report.
     #
-    def track_files(glob = nil)
-      return @track_files if defined?(@track_files) && glob.nil?
-      @track_files = glob
+    def track_files(glob)
+      @tracked_files = glob
+    end
+
+    #
+    # Returns the glob that will be used to include files that were not
+    # explicitly required.
+    #
+    def tracked_files
+      @tracked_files if defined?(@tracked_files)
     end
 
     #
@@ -143,9 +150,9 @@ module SimpleCov
     # Allows you to configure simplecov in a block instead of prepending SimpleCov to all config methods
     # you're calling.
     #
-    # SimpleCov.configure do
-    #   add_filter 'foobar'
-    # end
+    #     SimpleCov.configure do
+    #       add_filter 'foobar'
+    #     end
     #
     # This is equivalent to SimpleCov.add_filter 'foobar' and thus makes it easier to set a bunch of configure
     # options at once.
@@ -161,10 +168,11 @@ module SimpleCov
     # By default, it will call SimpleCov.result.format!
     #
     # Configure with:
-    #   SimpleCov.at_exit do
-    #     puts "Coverage done"
-    #     SimpleCov.result.format!
-    #   end
+    #
+    #     SimpleCov.at_exit do
+    #       puts "Coverage done"
+    #       SimpleCov.result.format!
+    #     end
     #
     def at_exit(&block)
       return proc {} unless running || block_given?
@@ -249,15 +257,18 @@ module SimpleCov
 
     #
     # Add a filter to the processing chain.
-    # There are three ways to define a filter:
+    # There are four ways to define a filter:
     #
     # * as a String that will then be matched against all source files' file paths,
-    #   SimpleCov.add_filter 'app/models' # will reject all your models
+    #     SimpleCov.add_filter 'app/models' # will reject all your models
     # * as a block which will be passed the source file in question and should either
     #   return a true or false value, depending on whether the file should be removed
-    #   SimpleCov.add_filter do |src_file|
-    #     File.basename(src_file.filename) == 'environment.rb'
-    #   end # Will exclude environment.rb files from the results
+    #     SimpleCov.add_filter do |src_file|
+    #       File.basename(src_file.filename) == 'environment.rb'
+    #     end # Will exclude environment.rb files from the results
+    # * as an array of strings that are matched against all sorce files' file
+    #   paths and then ignored (basically string filter multiple times)
+    #     SimpleCov.add_filter ['app/models', 'app/helpers'] # ignores both dirs
     # * as an instance of a subclass of SimpleCov::Filter. See the documentation there
     #   on how to define your own filter classes
     #
@@ -277,7 +288,7 @@ module SimpleCov
   private
 
     #
-    # The actal filter processor. Not meant for direct use
+    # The actual filter processor. Not meant for direct use
     #
     def parse_filter(filter_argument = nil, &filter_proc)
       if filter_argument.is_a?(SimpleCov::Filter)

data/lib/simplecov/defaults.rb

@@ -29,6 +29,7 @@ SimpleCov.profiles.define "rails" do
   add_filter "/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"
@@ -78,15 +79,18 @@ at_exit do # rubocop:disable Metrics/BlockLength
         $stderr.printf("File (%s) is only (%.2f%%) covered. This is below the expected minimum coverage per file of (%.2f%%).\n", SimpleCov.result.least_covered_file, covered_percentages.min, SimpleCov.minimum_coverage_by_file)
         @exit_status = SimpleCov::ExitCodes::MINIMUM_COVERAGE
       elsif (last_run = SimpleCov::LastRun.read) # rubocop:disable Metrics/BlockNesting
-        diff = last_run["result"]["covered_percent"] - covered_percent
-        if diff > SimpleCov.maximum_coverage_drop # rubocop:disable Metrics/BlockNesting
-          $stderr.printf("Coverage has dropped by %.2f%% since the last time (maximum allowed: %.2f%%).\n", diff, SimpleCov.maximum_coverage_drop)
+        coverage_diff = last_run["result"]["covered_percent"] - covered_percent
+        if coverage_diff > SimpleCov.maximum_coverage_drop # rubocop:disable Metrics/BlockNesting
+          $stderr.printf("Coverage has dropped by %.2f%% since the last time (maximum allowed: %.2f%%).\n", coverage_diff, SimpleCov.maximum_coverage_drop)
           @exit_status = SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
         end
       end
     end
 
-    SimpleCov::LastRun.write(:result => {:covered_percent => covered_percent})
+    # Don't overwrite last_run file if refuse_coverage_drop option is enabled and the coverage has dropped
+    unless @exit_status == SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP
+      SimpleCov::LastRun.write(:result => {:covered_percent => covered_percent})
+    end
   end
 
   # Force exit with stored status (see github issue #5)
@@ -95,12 +99,7 @@ at_exit do # rubocop:disable Metrics/BlockLength
 end
 
 # Autoload config from ~/.simplecov if present
-require "etc"
-home_dir = 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
+require "simplecov/load_global_config"
 
 # Autoload config from .simplecov if present
 # Recurse upwards until we find .simplecov or reach the root directory

data/lib/simplecov/last_run.rb

@@ -9,7 +9,9 @@ module SimpleCov
 
       def read
         return nil unless File.exist?(last_run_path)
-        JSON.parse(File.read(last_run_path))
+        json = File.read(last_run_path)
+        return nil if json.strip.empty?
+        JSON.parse(json)
       end
 
       def write(json)

data/lib/simplecov/load_global_config.rb

@@ -0,0 +1,6 @@
+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/raw_coverage.rb

@@ -0,0 +1,39 @@
+module SimpleCov
+  module RawCoverage
+  module_function
+
+    # Merges multiple Coverage.result hashes
+    def merge_results(*results)
+      results.reduce({}) do |result, merged|
+        merge_resultsets(result, merged)
+      end
+    end
+
+    # Merges two Coverage.result hashes
+    def merge_resultsets(result1, result2)
+      (result1.keys | result2.keys).each_with_object({}) do |filename, merged|
+        file1 = result1[filename]
+        file2 = result2[filename]
+        merged[filename] = merge_file_coverage(file1, file2)
+      end
+    end
+
+    def merge_file_coverage(file1, file2)
+      return (file1 || file2).dup unless file1 && file2
+
+      file1.map.with_index do |count1, index|
+        count2 = file2[index]
+        merge_line_coverage(count1, count2)
+      end
+    end
+
+    def merge_line_coverage(count1, count2)
+      sum = count1.to_i + count2.to_i
+      if sum.zero? && (count1.nil? || count2.nil?)
+        nil
+      else
+        sum
+      end
+    end
+  end
+end

data/lib/simplecov/result.rb

@@ -24,7 +24,6 @@ module SimpleCov
     # 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.extend(SimpleCov::HashMergeHelper) unless original_result.is_a? SimpleCov::HashMergeHelper
       @original_result = original_result.freeze
       @files = SimpleCov::FileList.new(original_result.map do |filename, coverage|
         SimpleCov::SourceFile.new(filename, coverage) if File.file?(filename)

data/lib/simplecov/result_merger.rb

@@ -54,20 +54,24 @@ module SimpleCov
         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
-        merged = {}
-        results.each do |result|
-          merged = result.original_result.merge_resultset(merged)
-        end
-        result = SimpleCov::Result.new(merged)
-        # Specify the command name
-        result.command_name = results.map(&:command_name).sort.join(", ")
-        result
+        merge_results(*results)
       end
 
       # Saves the given SimpleCov::Result in the resultset cache

data/lib/simplecov/source_file.rb

@@ -91,22 +91,24 @@ module SimpleCov
     # Returns all source lines for this file as instances of SimpleCov::SourceFile::Line,
     # and thus including coverage data. Aliased as :source_lines
     def lines
-      return @lines if defined? @lines
+      @lines ||= build_lines
+    end
+    alias source_lines lines
 
-      # Warning to identify condition from Issue #56
-      if coverage.size > src.size
-        $stderr.puts "Warning: coverage data provided by Coverage [#{coverage.size}] exceeds number of lines in #{filename} [#{src.size}]"
-      end
+    def build_lines
+      coverage_exceeding_source_warn if coverage.size > src.size
 
-      # Initialize lines
-      @lines = []
-      src.each_with_index do |src, i|
-        @lines << SimpleCov::SourceFile::Line.new(src, i + 1, coverage[i])
+      lines = src.map.with_index(1) do |src, i|
+        SimpleCov::SourceFile::Line.new(src, i, coverage[i - 1])
       end
-      process_skipped_lines!
-      @lines
+
+      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
-    alias source_lines lines
 
     # Access SimpleCov::SourceFile::Line source lines by line number
     def line(number)
@@ -115,31 +117,29 @@ module SimpleCov
 
     # The coverage for this file in percent. 0 if the file has no relevant lines
     def covered_percent
-      return 100.0 if lines.length.zero? || lines.length == never_lines.count
-      relevant_lines = lines.count - never_lines.count - skipped_lines.count
-      if relevant_lines.zero?
-        0.0
-      else
-        Float(covered_lines.count * 100.0 / relevant_lines.to_f)
-      end
+      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 lines.length.zero? || lines.length == never_lines.count
+      return 0.0 if no_lines?
 
-      lines_strength = 0
-      lines.each do |c|
-        lines_strength += c.coverage if c.coverage
-      end
+      round_float(lines_strength / relevant_lines.to_f, 1)
+    end
 
-      effective_lines_count = Float(lines.count - never_lines.count - skipped_lines.count)
+    def no_lines?
+      lines.length.zero? || lines.length == never_lines.size
+    end
 
-      if effective_lines_count.zero?
-        0.0
-      else
-        strength = lines_strength / effective_lines_count
-        round_float(strength, 1)
-      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
@@ -166,16 +166,18 @@ module SimpleCov
 
     # Returns the number of relevant lines (covered + missed)
     def lines_of_code
-      covered_lines.count + missed_lines.count
+      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!
+    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

data/lib/simplecov/version.rb

@@ -1,5 +1,5 @@
 module SimpleCov
-  version = "0.13.0"
+  version = "0.14.0"
 
   def version.to_a
     split(".").map(&:to_i)

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

data/spec/faked_project/features/step_definitions/my_steps.rb

@@ -6,7 +6,7 @@ When /^I write my cukes for the fake project$/ do
   expect(1).to eq(1)
 end
 
-Then /^I make all neccessary tests in a single step$/ do
+Then /^I make all necessary tests in a single step$/ do
   expect(FakedProject.foo).to eq("bar")
 
   expect(FrameworkSpecific.cucumber).to eq("Only tested in Cucumber")

data/spec/faked_project/features/test_stuff.feature

@@ -3,4 +3,4 @@ Feature: Foo
   Scenario: Test stuff
     Given I want to keep stuff simple
     When I write my cukes for the fake project
-    Then I make all neccessary tests in a single step
+    Then I make all necessary tests in a single step

data/spec/file_list_spec.rb

@@ -19,16 +19,16 @@ if SimpleCov.usable?
       expect(subject.missed_lines).to eq(3)
     end
 
-    it "has 19 never lines" do
-      expect(subject.never_lines).to eq(19)
+    it "has 17 never lines" do
+      expect(subject.never_lines).to eq(17)
     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)
+    it "has 5 skipped lines" do
+      expect(subject.skipped_lines).to eq(5)
     end
 
     it "has the correct covered percent" do

data/spec/helper.rb

@@ -1,5 +1,7 @@
-require "simplecov"
 require "rspec"
+# loaded before simplecov to also capture parse time warnings
+require "support/fail_rspec_on_ruby_warning"
+require "simplecov"
 
 SimpleCov.coverage_dir("tmp/coverage")
 

data/spec/last_run_spec.rb

@@ -0,0 +1,48 @@
+require "helper"
+
+if SimpleCov.usable?
+  describe SimpleCov::LastRun do
+    subject { SimpleCov::LastRun }
+
+    it "defines a last_run_path" do
+      expect(subject.last_run_path).to include "tmp/coverage/.last_run.json"
+    end
+
+    it "writes json to its last_run_path that can be parsed again" do
+      structure = [{"key" => "value"}]
+      subject.write(structure)
+      file_contents = File.read(subject.last_run_path)
+      expect(JSON.parse(file_contents)).to eq structure
+    end
+
+    context "reading" do
+      context "but the last_run file does not exist" do
+        before { File.delete(subject.last_run_path) if File.exist?(subject.last_run_path) }
+
+        it "returns nil" do
+          expect(subject.read).to be_nil
+        end
+      end
+
+      context "a non empty result" do
+        before { subject.write([]) }
+
+        it "reads json from its last_run_path" do
+          expect(subject.read).to eq([])
+        end
+      end
+
+      context "an empty result" do
+        before do
+          File.open(subject.last_run_path, "w+") do |f|
+            f.puts ""
+          end
+        end
+
+        it "returns nil" do
+          expect(subject.read).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/raw_coverage_spec.rb

@@ -0,0 +1,92 @@
+require "helper"
+
+if SimpleCov.usable?
+  describe SimpleCov::RawCoverage do
+    describe "with two faked coverage resultsets" do
+      before do
+        @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],
+          source_fixture("app/controllers/sample_controller.rb") => [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil],
+          source_fixture("resultset1.rb") => [1, 1, 1, 1],
+          source_fixture("parallel_tests.rb") => [nil, 0, nil, 0],
+          source_fixture("conditionally_loaded_1.rb") => [nil, 0, 1],  # loaded only in the first resultset
+          source_fixture("three.rb") => [nil, 1, 1],
+        }
+
+        @resultset2 = {
+          source_fixture("sample.rb") => [1, nil, 1, 1, nil, nil, 1, 1, nil, nil],
+          source_fixture("app/models/user.rb") => [nil, 1, 5, 1, nil, nil, 1, 0, nil, nil],
+          source_fixture("app/controllers/sample_controller.rb") => [nil, 3, 1, nil, nil, nil, 1, 0, nil, nil],
+          source_fixture("resultset2.rb") => [nil, 1, 1, nil],
+          source_fixture("parallel_tests.rb") => [nil, nil, 0, 0],
+          source_fixture("conditionally_loaded_2.rb") => [nil, 0, 1],  # loaded only in the second resultset
+          source_fixture("three.rb") => [nil, 1, 4],
+        }
+
+        @resultset3 = {
+          source_fixture("three.rb") => [nil, 1, 2],
+        }
+      end
+
+      context "a merge" do
+        subject do
+          SimpleCov::RawCoverage.merge_results(@resultset1, @resultset2, @resultset3)
+        end
+
+        it "has proper results for sample.rb" do
+          expect(subject[source_fixture("sample.rb")]).to eq([1, 1, 2, 2, nil, nil, 2, 2, nil, nil])
+        end
+
+        it "has proper results for user.rb" do
+          expect(subject[source_fixture("app/models/user.rb")]).to eq([nil, 2, 6, 2, nil, nil, 2, 0, nil, nil])
+        end
+
+        it "has proper results for sample_controller.rb" do
+          expect(subject[source_fixture("app/controllers/sample_controller.rb")]).to eq([nil, 4, 2, 1, nil, nil, 2, 0, nil, nil])
+        end
+
+        it "has proper results for resultset1.rb" do
+          expect(subject[source_fixture("resultset1.rb")]).to eq([1, 1, 1, 1])
+        end
+
+        it "has proper results for resultset2.rb" do
+          expect(subject[source_fixture("resultset2.rb")]).to eq([nil, 1, 1, nil])
+        end
+
+        it "has proper results for parallel_tests.rb" do
+          expect(subject[source_fixture("parallel_tests.rb")]).to eq([nil, nil, nil, 0])
+        end
+
+        it "has proper results for conditionally_loaded_1.rb" do
+          expect(subject[source_fixture("conditionally_loaded_1.rb")]).to eq([nil, 0, 1])
+        end
+
+        it "has proper results for conditionally_loaded_2.rb" do
+          expect(subject[source_fixture("conditionally_loaded_2.rb")]).to eq([nil, 0, 1])
+        end
+
+        it "has proper results for three.rb" do
+          expect(subject[source_fixture("three.rb")]).to eq([nil, 3, 7])
+        end
+      end
+    end
+
+    it "merges frozen resultsets" do
+      resultset1 = {
+        source_fixture("sample.rb").freeze => [nil, 1, 1, 1, nil, nil, 1, 1, nil, nil].freeze,
+        source_fixture("app/models/user.rb").freeze => [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil].freeze,
+      }.freeze
+
+      resultset2 = {
+        source_fixture("sample.rb").freeze => [1, nil, 1, 1, nil, nil, 1, 1, nil, nil].freeze,
+      }.freeze
+
+      merged_result = SimpleCov::RawCoverage.merge_results(resultset1, resultset2)
+      expect(merged_result.keys).to eq(resultset1.keys)
+      expect(merged_result.values.map(&:frozen?)).to eq([false, false])
+      expect(merged_result[source_fixture("sample.rb")]).to eq([1, 1, 2, 2, nil, nil, 2, 2, nil, nil])
+      expect(merged_result[source_fixture("app/models/user.rb")]).to eq([nil, 1, 1, 1, nil, nil, 1, 0, nil, nil])
+    end
+  end
+end

data/spec/{merge_helpers_spec.rb → result_merger_spec.rb}

@@ -1,7 +1,7 @@
 require "helper"
 
 if SimpleCov.usable?
-  describe "merge helpers" do
+  describe SimpleCov::ResultMerger do
     describe "with two faked coverage resultsets" do
       before do
         SimpleCov.use_merging true
@@ -12,7 +12,7 @@ if SimpleCov.usable?
           source_fixture("resultset1.rb") => [1, 1, 1, 1],
           source_fixture("parallel_tests.rb") => [nil, 0, nil, 0],
           source_fixture("conditionally_loaded_1.rb") => [nil, 0, 1],  # loaded only in the first resultset
-        }.extend(SimpleCov::HashMergeHelper)
+        }
 
         @resultset2 = {
           source_fixture("sample.rb") => [1, nil, 1, 1, nil, nil, 1, 1, nil, nil],
@@ -24,44 +24,6 @@ if SimpleCov.usable?
         }
       end
 
-      context "a merge" do
-        subject do
-          @resultset1.merge_resultset(@resultset2)
-        end
-
-        it "has proper results for sample.rb" do
-          expect(subject[source_fixture("sample.rb")]).to eq([1, 1, 2, 2, nil, nil, 2, 2, nil, nil])
-        end
-
-        it "has proper results for user.rb" do
-          expect(subject[source_fixture("app/models/user.rb")]).to eq([nil, 2, 6, 2, nil, nil, 2, 0, nil, nil])
-        end
-
-        it "has proper results for sample_controller.rb" do
-          expect(subject[source_fixture("app/controllers/sample_controller.rb")]).to eq([nil, 4, 2, 1, nil, nil, 2, 0, nil, nil])
-        end
-
-        it "has proper results for resultset1.rb" do
-          expect(subject[source_fixture("resultset1.rb")]).to eq([1, 1, 1, 1])
-        end
-
-        it "has proper results for resultset2.rb" do
-          expect(subject[source_fixture("resultset2.rb")]).to eq([nil, 1, 1, nil])
-        end
-
-        it "has proper results for parallel_tests.rb" do
-          expect(subject[source_fixture("parallel_tests.rb")]).to eq([nil, nil, nil, 0])
-        end
-
-        it "has proper results for conditionally_loaded_1.rb" do
-          expect(subject[source_fixture("conditionally_loaded_1.rb")]).to eq([nil, 0, 1])
-        end
-
-        it "has proper results for conditionally_loaded_2.rb" do
-          expect(subject[source_fixture("conditionally_loaded_2.rb")]).to eq([nil, 0, 1])
-        end
-      end
-
       # See Github issue #6
       it "returns an empty hash when the resultset cache file is empty" do
         File.open(SimpleCov::ResultMerger.resultset_path, "w+") { |f| f.puts "" }

data/spec/source_file_spec.rb

@@ -42,12 +42,12 @@ if SimpleCov.usable?
         expect(subject.missed_lines.map(&:line)).to eq([8])
       end
 
-      it "returns lines number 1, 5, 6, 9, 10, 11, 15, 16 for never_lines" do
-        expect(subject.never_lines.map(&:line)).to eq([1, 5, 6, 9, 10, 11, 15, 16])
+      it "returns lines number 1, 5, 6, 9, 10, 16 for never_lines" do
+        expect(subject.never_lines.map(&:line)).to eq([1, 5, 6, 9, 10, 16])
       end
 
-      it "returns line numbers 12, 13, 14 for skipped_lines" do
-        expect(subject.skipped_lines.map(&:line)).to eq([12, 13, 14])
+      it "returns line numbers 11, 12, 13, 14, 15 for skipped_lines" do
+        expect(subject.skipped_lines.map(&:line)).to eq([11, 12, 13, 14, 15])
       end
 
       it "has 80% covered_percent" do

data/spec/support/fail_rspec_on_ruby_warning.rb

@@ -0,0 +1,75 @@
+# Borrowed and heavily adjusted from:
+# https://github.com/metricfu/metric_fu/blob/master/spec/capture_warnings.rb
+require "fileutils"
+
+class FailOnWarnings
+  def initialize
+    @stderr_stream = StringIO.new
+    @app_root = Dir.pwd
+  end
+
+  def collect_warnings
+    $stderr = @stderr_stream
+    $VERBOSE = true
+  end
+
+  def process_warnings
+    lines = close_stream
+    app_warnings, other_warnings = split_lines(lines)
+
+    print_own_warnings(app_warnings) if app_warnings.any?
+    write_other_warnings_to_tmp(other_warnings) if other_warnings.any?
+    fail_script(app_warnings) if app_warnings.any?
+  end
+
+private
+
+  def close_stream
+    $stderr = STDERR
+
+    @stderr_stream.rewind
+    lines = @stderr_stream.read.split("\n")
+    lines.uniq!
+    @stderr_stream.close
+    lines
+  end
+
+  def split_lines(lines)
+    lines.partition { |line| line.include?(@app_root) }
+  end
+
+  def print_own_warnings(app_warnings)
+    puts ""
+    puts ""
+    puts <<-WARNINGS
+#{'-' * 30} app warnings: #{'-' * 30}
+    #{app_warnings.join("\n")}
+    #{'-' * 75}
+    WARNINGS
+  end
+
+  def write_other_warnings_to_tmp(other_warnings)
+    output_dir = File.join(@app_root, "tmp")
+    FileUtils.mkdir_p(output_dir)
+    output_file = File.join(output_dir, "warnings.txt")
+    File.open(output_file, "w") do |file|
+      file.write(other_warnings.join("\n") << "\n")
+    end
+    puts
+    puts "Non-app warnings written to tmp/warnings.txt"
+    puts
+  end
+
+  def fail_script(app_warnings)
+    abort "Failing build due to app warnings: #{app_warnings.inspect}"
+  end
+end
+
+warning_collector = FailOnWarnings.new
+warning_collector.collect_warnings
+
+RSpec.configure do |config|
+  config.after(:suite) do
+    warning_collector.process_warnings
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simplecov
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Christoph Olszowka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-25 00:00:00.000000000 Z
+date: 2017-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -141,11 +141,12 @@ files:
 - lib/simplecov/formatter/simple_formatter.rb
 - lib/simplecov/jruby_fix.rb
 - lib/simplecov/last_run.rb
-- lib/simplecov/merge_helpers.rb
+- lib/simplecov/load_global_config.rb
 - lib/simplecov/no_defaults.rb
 - lib/simplecov/profiles.rb
 - lib/simplecov/railtie.rb
 - lib/simplecov/railties/tasks.rake
+- lib/simplecov/raw_coverage.rb
 - lib/simplecov/result.rb
 - lib/simplecov/result_merger.rb
 - lib/simplecov/source_file.rb
@@ -153,6 +154,8 @@ files:
 - simplecov.gemspec
 - spec/1_8_fallbacks_spec.rb
 - spec/command_guesser_spec.rb
+- spec/config_loader_spec.rb
+- spec/configuration_spec.rb
 - spec/deleted_source_spec.rb
 - spec/faked_project/Gemfile
 - spec/faked_project/Rakefile
@@ -189,12 +192,15 @@ files:
 - spec/fixtures/sample.rb
 - spec/fixtures/utf-8.rb
 - spec/helper.rb
-- spec/merge_helpers_spec.rb
+- spec/last_run_spec.rb
 - spec/multi_formatter_spec.rb
+- spec/raw_coverage_spec.rb
+- spec/result_merger_spec.rb
 - spec/result_spec.rb
 - spec/return_codes_spec.rb
 - spec/source_file_line_spec.rb
 - spec/source_file_spec.rb
+- spec/support/fail_rspec_on_ruby_warning.rb
 homepage: http://github.com/colszowka/simplecov
 licenses:
 - MIT

data/lib/simplecov/merge_helpers.rb

@@ -1,37 +0,0 @@
-module SimpleCov
-  module ArrayMergeHelper
-    # Merges an array of coverage results with self
-    def merge_resultset(array)
-      new_array = dup
-      array.each_with_index do |element, i|
-        pair = [element, new_array[i]]
-        new_array[i] = if pair.any?(&:nil?) && pair.map(&:to_i).all?(&:zero?)
-                         nil
-                       else
-                         element.to_i + new_array[i].to_i
-                       end
-      end
-      new_array
-    end
-  end
-end
-
-module SimpleCov
-  module HashMergeHelper
-    # Merges the given Coverage.result hash with self
-    def merge_resultset(hash)
-      new_resultset = {}
-      (keys + hash.keys).each do |filename|
-        new_resultset[filename] = nil
-      end
-
-      new_resultset.each_key do |filename|
-        result1 = self[filename]
-        result2 = hash[filename]
-        new_resultset[filename] =
-          result1 && result2 ? result1.extend(ArrayMergeHelper).merge_resultset(result2) : (result1 || result2).dup
-      end
-      new_resultset
-    end
-  end
-end