covet 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f7fd3d912a0b3a182a3b8004c0d4bd4b7a75c313
-  data.tar.gz: 090be05aac594fac1273ef2ea6c90a732367d021
+  metadata.gz: 904a67d9659b9da5e67d2c640d3deb68c2ce8e2d
+  data.tar.gz: a0a689a74a1048a23e87a331bb6b53104512549b
 SHA512:
-  metadata.gz: 90adde7bc36fbfe9550e16212bdd52da65161adb3de5c003227b9a5782990762ce9b6c552148748652d6a559f48d7f190b6084a14e107c24d8dcc8c10b75a726
-  data.tar.gz: a3ddfd5fd2997c04542bb35e3e7c2ce34ba29f6bf1c6853d0502b84eb2dcc7e482b3b67ef6ab71c19c75a965fedd2ff924a30d4ff8820fc6030c0d3c2cce1f25
+  metadata.gz: e31c2ff532fdbfb83a785508705073224113a551ccdd7f8724ee606a4ae6e3bc9d47660fad219679e33f1259da947f5a41008ebada1b0e9518da100333766ec4
+  data.tar.gz: b52e7e4ce821ad4d399fcae3d017d541606e49e2ea0dddaee2be2f32c3104b3fe59f1f311ab50b259e3790ac10dfcedb62ce71d3460f935efc11515feeed192b

data/.gitignore

@@ -0,0 +1,13 @@
+run_log.json
+run_log_index.json
+/tmp
+*.so
+*.bundle
+*.dll
+*.o
+TODO
+Gemfile.lock
+gemfiles/*.lock
+*.gem
+/vendor
+.byebug_*

data/.travis.yml

@@ -0,0 +1,10 @@
+# .travis.yml
+rvm:
+  #- 1.9.3
+  - 2.2.0
+gemfile:
+  - gemfiles/minitest4-0-0.gemfile
+  - gemfiles/minitest5-0-8.gemfile
+  - gemfiles/minitest5-3-3.gemfile
+  - gemfiles/minitest5-7-0.gemfile
+script: "bundle exec rake test"

data/Gemfile

@@ -4,9 +4,11 @@ gemspec
 group :test, :development do
   gem 'rspec'
   gem 'minitest'
-  #if RUBY_VERSION.to_i < 2
-    #gem 'debugger'
-  #else
-    #gem 'byebug'
-  #end
+  if ENV['COVET_DEBUG']
+    if RUBY_VERSION.to_i < 2
+      gem 'debugger'
+    else
+      gem 'byebug'
+    end
+  end
 end

data/README.md

@@ -26,6 +26,10 @@ certain lines of the application code.
 Usage
 -----
 
+Add `covet` to your Gemfile in your test or development `:group`, or:
+
+    $ gem install covet
+
 Coverage Collection:
 
 Run your test suite with coverage collection on. To enable this,

data/Rakefile

@@ -2,8 +2,10 @@ require 'rake/testtask'
 require 'rake/extensiontask'
 require 'rspec/core/rake_task'
 require 'rake/clean'
+require 'wwtd/tasks'
 
 task :default => [:tests_and_specs]
+task :travis => [:clobber, :compile, :wwtd] # run travis builds locally
 
 Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb'].to_a
@@ -23,7 +25,9 @@ desc 'Run minitest and rspec tests (default)'
 task :tests_and_specs => [:test, :spec]
 
 desc 'compile internal coverage C extension'
-Rake::ExtensionTask.new('covet_coverage')
+Rake::ExtensionTask.new('covet_coverage') do |ext| # rake compile
+  ext.lib_dir = 'lib' # output covet_coverage.so to 'lib' directory
+end
 
 desc 'recompile internal coverage C extension'
 task :recompile => [:clobber, :compile, :tests_and_specs]
@@ -32,6 +36,7 @@ task :recompile => [:clobber, :compile, :tests_and_specs]
 CLOBBER.include(
   'run_log.json',
   'run_log_index.json',
-  'ext/covet_coverage/*.{so,o}',
+  'lib/*.{so,o,bundle}',
   'ext/covet_coverage/Makefile',
+  'gemfiles/*.lock',
 )

data/ext/covet_coverage/covet_coverage.c

@@ -114,7 +114,7 @@ rb_coverage_result(void)
     VALUE coverages = rb_get_coverages();
     VALUE ncoverages = rb_hash_new();
     if (!RTEST(coverages)) {
-        rb_raise(rb_eRuntimeError, "coverage measurement is not enabled");
+        rb_raise(rb_eRuntimeError, "coverage measurement is not enabled (covet)");
     }
     st_foreach(RHASH_TBL(coverages), coverage_result_i, ncoverages);
     rb_hash_freeze(ncoverages);

data/gemfiles/minitest4-0-0.gemfile

@@ -0,0 +1,9 @@
+# vim: ft=ruby
+
+source 'https://rubygems.org'
+gemspec :path => '../'
+
+group :test, :development do
+  gem 'minitest', '4.0.0'
+  gem 'rspec'
+end

data/gemfiles/minitest5-0-8.gemfile

@@ -0,0 +1,9 @@
+# vim: ft=ruby
+
+source 'https://rubygems.org'
+gemspec :path => '../'
+
+group :test, :development do
+  gem 'minitest', '5.0.8'
+  gem 'rspec'
+end

data/gemfiles/minitest5-3-3.gemfile

@@ -0,0 +1,9 @@
+# vim: ft=ruby
+
+source 'https://rubygems.org'
+gemspec :path => '../'
+
+group :test, :development do
+  gem 'minitest', '5.3.3'
+  gem 'rspec'
+end

data/gemfiles/minitest5-7-0.gemfile

@@ -0,0 +1,9 @@
+# vim: ft=ruby
+
+source 'https://rubygems.org'
+gemspec :path => '../'
+
+group :test, :development do
+  gem 'minitest', '5.7.0'
+  gem 'rspec'
+end

data/lib/covet.rb

@@ -4,7 +4,7 @@ if defined?(Coverage) && Coverage.respond_to?(:peek_result)
 else
   # TODO: error out if non-mri ruby
   begin
-    require_relative 'covet_coverage.so'
+    require_relative 'covet_coverage'
   rescue Exception # re-raised
     $stderr.puts "Error loading 'covet' C extension.\n" \
       "Please report this bug along with a backtrace. Thanks :)"
@@ -26,20 +26,21 @@ if ENV['COVET_DEBUG']
     gem 'byebug'
     require 'byebug'
   end
-else
-  if !defined?(debugger)
-    def debugger; end
-  end
+#else
+  #if !defined?(debugger)
+    #def debugger; end
+  #end
 end
 
 module Covet
   BASE_COVERAGE = {}
 
-  # @return Hash (frozen)
+  # @return Hash
   def self.options
     CLI.options || Options::DEFAULTS
   end
 
+  # Singleton for collecting and writing log information during the collection phase.
   def self.log_collection
     @log_collection
   end
@@ -51,6 +52,8 @@ module Covet
     :bufsize => 50,
   )
 
+  # Set the version control system to use for seeing which files have changed
+  # since a certain version.
   def self.vcs=(vcs)
     @vcs = vcs.intern
     if @vcs != :git
@@ -61,6 +64,8 @@ module Covet
 
   self.vcs = :git # default
 
+  # Set the test runner library to hook into, gathering and logging coverage
+  # information during the collection phase for each test method.
   def self.test_runner=(runner)
     @test_runner = runner.intern
     require_relative "covet/test_runners/#{runner}"
@@ -76,6 +81,8 @@ module Covet
     self.test_runner = :minitest # default
   end
 
+  # Tell `covet` the order in which your tests are run, which allows it to
+  # save space and time during the coverage collection phase in certain situations.
   VALID_TEST_ORDERS = [:random_seeded, :random, :ordered].freeze
   def self.test_order=(order)
     unless VALID_TEST_ORDERS.include?(order.intern)
@@ -109,10 +116,14 @@ module Covet
     self.test_directories = self.test_directories + ['spec']
   end
 
+  @coverage_collection_registered = false
+  # Register coverage collection with the test library `Covet.test_runner`.
+  # This happens during the collection phase.
   def self.register_coverage_collection!
     # stdlib Coverage can't run at the same time as CovetCoverage or
     # bad things will happen
     if defined?(Coverage) && !Coverage.respond_to?(:peek_result)
+      warn "The 'coverage' library is already loaded. It could cause issues with this library."
       # There's no way to tell if coverage is enabled or not, and
       # if we try stopping the coverage and it's not enabled, it raises
       # a RuntimeError.
@@ -122,8 +133,14 @@ module Covet
     Covet::TestRunners.const_get(
       @test_runner.to_s.capitalize
     ).hook_into_test_methods!
+    @coverage_collection_registered = true
+  end
+
+  def self.coverage_collection_registered?
+    @coverage_collection_registered
   end
 
+  # Returns the command line to run the tests given in `run_list`.
   # @return String
   def self.cmdline_for_run_list(run_list)
     Covet::TestRunners.const_get(
@@ -131,12 +148,12 @@ module Covet
     ).cmdline_for_run_list(run_list)
   end
 
-  # Returns coverage information for before `block` ran, and after `block` ran
+  # Returns coverage information for before block ran, and after block ran
   # for the codebase in its current state.
   # @return Array
   def self.coverage_before_and_after # yields
     before = CovetCoverage.peek_result
-    yield if block_given?
+    yield
     after = CovetCoverage.peek_result
     before = normalize_coverage_info(before)
     if Covet::BASE_COVERAGE.any?
@@ -147,6 +164,8 @@ module Covet
     [before, after]
   end
 
+  # Filter and compress `coverage_info` to make it more manageable to log
+  # to the collection file, and so that processing it will be faster.
   def self.normalize_coverage_info(coverage_info)
     filtered = CollectionFilter.filter(coverage_info)
     CollectionCompressor.compress(filtered)
@@ -170,6 +189,10 @@ module Covet
     cov_map
   end
 
+  # Get the difference between `before`'s coverage info and `after`'s coverage
+  # info.
+  # @param [Hash] before
+  # @param [Hash] after
   # @return Hash
   def self.diff_coverages(before, after)
     ret = after.each_with_object({}) do |(file_name, after_line_cov), res|
@@ -201,6 +224,6 @@ module Covet
   end
 end
 
-if ENV['COVET_COLLECT'] == '1'
+if ENV['COVET_COLLECT'] == '1' && !Covet.coverage_collection_registered?
   Covet.register_coverage_collection!
 end

data/lib/covet/collection_filter.rb

@@ -26,7 +26,7 @@ module Covet
     end
 
     # FIXME: should take filename AND method name
-    # @param Proc filter, arity = 1, takes filename
+    # @param [Proc] filter, arity = 1, takes filename
     def self.add_custom_filter(&filter)
       @@custom_filters << filter
     end

data/lib/covet/collection_task.rb

@@ -0,0 +1,60 @@
+require 'rake/tasklib'
+
+module Covet
+  # Define a new rake task to collect coverage information for a `TestTask`.
+  # Usage (in Rakefile):
+  #
+  #   require 'rake/testtask'
+  #   require 'covet/collection_task'
+  #
+  #   Rake::TestTask.new(:my_tests) do |t|
+  #     t.verbose = true
+  #   end
+  #
+  #   Covet::CollectionTask.new(:collect) do |t|
+  #     t.test_task = :my_tests
+  #     t.description = "Collect coverage information for my_tests"
+  #   end
+  #
+  # Now, we can can run '$ rake collect'.
+  class CollectionTask < Rake::TaskLib
+
+    attr_accessor :name
+    attr_accessor :description
+    attr_accessor :test_task # Rake::TestTask or Symbol
+    attr_accessor :covet_opts # Array of cmdline covet options
+
+    def initialize(name = :covet_collect) # yields
+      @name = name
+      @description = nil
+      @test_task = nil
+      @covet_opts = []
+      yield self if block_given?
+      define
+    end
+
+    # Define the task
+    def define
+      if @test_task.nil?
+        raise "#{self.class} '#{@name}' is not properly set up. " \
+          "This task needs a `test_task` that's either the `Rake::TestTask` " \
+          "object to test or the name of that `TestTask` object. You can assign " \
+          "it using the `test_task=` method on the instance of #{self.class}."
+      end
+      @description ||= "Collect coverage information for task '#{test_task_name}'"
+      desc @description
+      task @name do
+        cmd = %Q(covet -c "rake #{test_task_name}" #{@covet_opts.join(' ')}).strip
+        puts cmd
+        system cmd
+      end
+    end
+
+    private
+
+      def test_task_name
+        @test_task.respond_to?(:name) ? @test_task.name : @test_task
+      end
+
+  end
+end

data/lib/covet/log_file.rb

@@ -1,4 +1,6 @@
 require 'json'
+require 'tempfile'
+require 'fileutils'
 
 module Covet
   # Represents log file of JSON coverage information for each test method.
@@ -9,8 +11,6 @@ module Covet
   # disk at certain intervals. This way, we can also load the information in
   # chunks as well, using the same index file.
   class LogFile
-    require 'tempfile'
-    require 'fileutils'
 
     LoadError = Class.new(StandardError)
 

data/lib/covet/test_runners/minitest.rb

@@ -3,49 +3,284 @@ require 'rake/testtask'
 module Covet
   module TestRunners
     module Minitest
-      @covet_hooked = false
+      @hooked = false
       @create_collection_file_on_exit = true
       class << self
         attr_accessor :create_collection_file_on_exit
       end
 
       def self.hook_into_test_methods!
-        if @covet_hooked
+        if @hooked
           warn "Warning - Covet.register_coverage_collection! called multiple times"
           return
         end
         gem 'minitest'
-        require 'minitest'
-
-        ::Minitest.after_run do
-          after_t = Time.now
-          diff_t = after_t - ::Minitest::Runnable.covet_start_time
-          time_taken = sprintf("%.2f", diff_t)
-          Covet.log_collection << ['stats', {
-            :time_taken => time_taken,
-            :files_filtered => CollectionFilter.files_filtered,
-          }]
-          if Covet::TestRunners::Minitest.create_collection_file_on_exit
-            Covet.log_collection.finish!
-          else
-            $stderr.puts "Covet: skipped writing to collection file"
-          end
+        begin
+          require 'minitest' # minitest 5
+        rescue LoadError
+          require 'minitest/unit' # minitest 4
         end
+        version = defined?(::Minitest::VERSION) ?
+          ::Minitest::VERSION : # v >= 5
+          ::Minitest::Unit::VERSION # v < 5
+
+        if version.to_f >= 5.0
+          ::Minitest.after_run do
+            after_t = Time.now
+            diff_t = after_t - ::Minitest::Runnable.covet_start_time
+            time_taken = sprintf("%.2f", diff_t)
+            Covet.log_collection << ['stats', {
+              :time_taken => time_taken,
+              :files_filtered => CollectionFilter.files_filtered,
+            }]
+            if Covet::TestRunners::Minitest.create_collection_file_on_exit
+              Covet.log_collection.finish!
+            else
+              $stderr.puts "Covet: skipped writing to collection file"
+            end
+          end
+
+          if ::Minitest::Runnable.respond_to?(:run_one_method) # minitest > 5.0.8
+          ::Minitest::Runnable.class_eval do
+            @@covet_run_num = 0
+            @@covet_skips = 0
+            @@covet_failures = 0
+            @@covet_start_time = nil
+
+            class << self
+              def covet_start_time
+                @@covet_start_time
+              end
+
+              alias :covet_old_run_one_method :run_one_method
+
+              def run_one_method(klass, method_name, reporter)
+                # first run, collect coverage 'base' coverage information
+                # (coverage information for before any tests get run).
+                if @@covet_run_num == 0
+                  @@covet_start_time = Time.now
+                  base_coverage = CovetCoverage.peek_result
+                  base_coverage = Covet.normalize_coverage_info(base_coverage)
+                  if base_coverage.empty?
+                    warn "Warning - covet is not properly set up, as it must be required " \
+                      "before other libraries to work correctly.\nTry adding\n  require 'covet'\n" \
+                      "to the top of your test helper file."
+                  end
+                  Covet::BASE_COVERAGE.update base_coverage
+                  Covet.log_collection << ['base', base_coverage, {
+                    :version => Covet::VERSION,
+                    :options => Covet.options,
+                    :seed => Random::DEFAULT.seed,
+                  }]
+                end
+
+                @@covet_run_num += 1
+                file = nil
+                begin
+                  file = klass.instance_method(method_name).source_location[0]
+                rescue
+                  warn "\nWarning - Skipping collecting test coverage for method #{klass}##{method_name}\n"
+                  return
+                end
+
+                before = CovetCoverage.peek_result
+
+                # Run test method
+                before_t = Time.now
+                result = covet_old_run_one_method(klass, method_name, reporter)
+                after_t = Time.now
 
-        ::Minitest::Runnable.class_eval do
-          @@covet_run_num = 0
-          @@covet_skips = 0
-          @@covet_failures = 0
-          @@covet_start_time = nil
+                summary_reporter = result.first
+                skips = summary_reporter.results.select(&:skipped?).size
+
+                # test was skipped, don't record coverage info
+                if @@covet_skips != skips
+                  @@covet_skips = skips
+                  @@covet_failures += 1
+                  return result
+                end
+
+                # test failed, don't record coverage info
+                failures = summary_reporter.results.select(&:failures).size
+                if @@covet_failures != failures
+                  @@covet_failures = failures
+                  return result
+                end
+
+                after = CovetCoverage.peek_result
+
+                before_orig = Covet.normalize_coverage_info(before)
+                if Covet::BASE_COVERAGE.any?
+                  before = Covet.diff_coverages(Covet::BASE_COVERAGE, before_orig)
+                end
+
+                after_orig = Covet.normalize_coverage_info(after)
+                after = Covet.diff_coverages(before_orig, after_orig)
+                if @@covet_run_num > 1
+                  if [:random_seeded, :ordered].include?(Covet.options[:test_order])
+                    Covet::BASE_COVERAGE.update(after_orig)
+                  end
+                end
+
+                if after == before
+                  after = nil
+                end
+                Covet.log_collection << ["#{file}##{method_name}", after, {
+                  :time => sprintf("%.2f", after_t - before_t),
+                }]
+                result
+              # NOTE: if the interrupt is fired outside of `Minitest.run_one_method`, then the
+              # collection file gets logged to even on interrupt :(
+              rescue Interrupt, SystemExit
+                Covet::TestRunners::Minitest.create_collection_file_on_exit = false
+                raise
+              end
 
-          class << self
-            def covet_start_time
-              @@covet_start_time
             end
+          end
+          elsif ::Minitest::Runnable.respond_to?(:run)
+            # minitest ~ 5.0.8
+            ::Minitest::Runnable.class_eval do
+              @@covet_run_num = 0
+              @@covet_skips = 0
+              @@covet_failures = 0
+              @@covet_start_time = nil
+              class << self
+                def covet_start_time
+                  @@covet_start_time
+                end
+
+                alias :covet_old_run :run
+
+                def run(reporter, options = {})
+                  filter = options[:filter] || '/./'
+                  filter = Regexp.new $1 if filter =~ /\/(.*)\//
+                  filtered_methods = self.runnable_methods.find_all { |m|
+                    filter === m || filter === "#{self}##{m}"
+                  }
+
+                  failures = 0
+                  with_info_handler reporter do
+                    filtered_methods.each do |method_name|
+
+                      # first run, collect coverage 'base' coverage information
+                      # (coverage information for before any tests get run).
+                      if @@covet_run_num == 0
+                        @@covet_start_time = Time.now
+                        base_coverage = CovetCoverage.peek_result
+                        base_coverage = Covet.normalize_coverage_info(base_coverage)
+                        if base_coverage.empty?
+                          warn "Warning - covet is not properly set up, as it must be required " \
+                            "before other libraries to work correctly.\nTry adding\n  require 'covet'\n" \
+                            "to the top of your test helper file."
+                        end
+                        Covet::BASE_COVERAGE.update base_coverage
+                        Covet.log_collection << ['base', base_coverage, {
+                          :version => Covet::VERSION,
+                          :options => Covet.options,
+                          :seed => Random::DEFAULT.seed,
+                        }]
+                      end
+
+                      @@covet_run_num += 1
+                      file = nil
+                      begin
+                        file = instance_method(method_name).source_location[0]
+                      rescue
+                        warn "\nWarning - Skipping collecting test coverage for method #{klass}##{method_name}\n"
+                        next
+                      end
+
+                      before = CovetCoverage.peek_result
+
+                      # Run test method
+                      before_t = Time.now
+                      result = self.new(method_name).run
+                      after_t = Time.now
+                      raise "#{self}#run _must_ return self" unless self === result
+                      ret = reporter.record result
+
+                      if result.skipped?
+                        @@covet_skips += 1
+                        next
+                      end
+
+                      # test failed, don't record coverage info
+                      new_failures = result.failures.size
+                      if new_failures > failures
+                        @@covet_failures += 1
+                        failures += 1
+                        next
+                      end
+
+                      after = CovetCoverage.peek_result
+
+                      before_orig = Covet.normalize_coverage_info(before)
+                      if Covet::BASE_COVERAGE.any?
+                        before = Covet.diff_coverages(Covet::BASE_COVERAGE, before_orig)
+                      end
+
+                      after_orig = Covet.normalize_coverage_info(after)
+                      after = Covet.diff_coverages(before_orig, after_orig)
+                      if @@covet_run_num > 1
+                        if [:random_seeded, :ordered].include?(Covet.options[:test_order])
+                          Covet::BASE_COVERAGE.update(after_orig)
+                        end
+                      end
+
+                      if after == before
+                        after = nil
+                      end
 
-            alias :covet_old_run_one_method :run_one_method
+                      Covet.log_collection << ["#{file}##{method_name}", after, {
+                        :time => sprintf("%.2f", after_t - before_t),
+                      }]
 
-            def run_one_method(klass, method_name, reporter)
+                      ret
+                    end
+                  end
+                # NOTE: if the interrupt is fired outside of `Minitest.run_one_method`, then the
+                # collection file gets logged to even on interrupt :(
+                rescue Interrupt, SystemExit
+                  Covet::TestRunners::Minitest.create_collection_file_on_exit = false
+                  raise
+                end
+
+              end
+            end
+          else
+            raise "Minitest version #{::Minitest::VERSION rescue '?'} not supported."
+          end
+        elsif defined?(::Minitest::Unit::TestCase) && ::Minitest::Unit::TestCase.method_defined?(:run)
+          ::Minitest::Unit.after_tests do
+            after_t = Time.now
+            diff_t = after_t - ::Minitest::Unit::TestCase.covet_start_time
+            time_taken = sprintf("%.2f", diff_t)
+            Covet.log_collection << ['stats', {
+              :time_taken => time_taken,
+              :files_filtered => CollectionFilter.files_filtered,
+            }]
+            if Covet::TestRunners::Minitest.create_collection_file_on_exit
+              Covet.log_collection.finish!
+            else
+              $stderr.puts "Covet: skipped writing to collection file"
+            end
+          end
+          ::Minitest::Unit::TestCase.class_eval do
+            @@covet_run_num = 0
+            @@covet_skips = 0
+            @@covet_failures = 0
+            @@covet_start_time = nil
+
+            class << self
+              def covet_start_time
+                @@covet_start_time
+              end
+            end
+
+            alias :covet_old_run :run
+
+            def run(runner)
               # first run, collect coverage 'base' coverage information
               # (coverage information for before any tests get run).
               if @@covet_run_num == 0
@@ -58,8 +293,6 @@ module Covet
                     "to the top of your test helper file."
                 end
                 Covet::BASE_COVERAGE.update base_coverage
-                # TODO: save Random::DEFAULT.seed in run log file if Covet.options[:test_order] == :random_seeded,
-                # then we can run the methods in the same order as before.
                 Covet.log_collection << ['base', base_coverage, {
                   :version => Covet::VERSION,
                   :options => Covet.options,
@@ -70,21 +303,19 @@ module Covet
               @@covet_run_num += 1
               file = nil
               begin
-                file = klass.instance_method(method_name).source_location[0]
+                file = method(self.__name__).source_location[0]
               rescue
-                warn "\nWarning - Skipping collecting test coverage for method #{klass}##{method_name}\n"
+                warn "\nWarning - Skipping collecting test coverage for method #{self.class}##{self.__name__}\n"
                 return
               end
-
               before = CovetCoverage.peek_result
 
               # Run test method
               before_t = Time.now
-              result = covet_old_run_one_method(klass, method_name, reporter)
+              result = covet_old_run(runner)
               after_t = Time.now
 
-              summary_reporter = result.first
-              skips = summary_reporter.results.select(&:skipped?).size
+              skips = runner.skips
 
               # test was skipped, don't record coverage info
               if @@covet_skips != skips
@@ -94,7 +325,7 @@ module Covet
               end
 
               # test failed, don't record coverage info
-              failures = summary_reporter.results.select(&:failures).size
+              failures = runner.failures
               if @@covet_failures != failures
                 @@covet_failures = failures
                 return result
@@ -118,20 +349,22 @@ module Covet
               if after == before
                 after = nil
               end
-              Covet.log_collection << ["#{file}##{method_name}", after, {
+              Covet.log_collection << ["#{file}##{self.__name__}", after, {
                 :time => sprintf("%.2f", after_t - before_t),
               }]
               result
-            # NOTE: if the interrupt is fired outside of `Minitest.run_one_method`, then the
+            # NOTE: if the interrupt is fired outside of `Minitest::Unit::TestCase.run`, then the
             # collection file gets logged even on interrupt :(
-            rescue Interrupt
+            rescue Interrupt, SystemExit
               Covet::TestRunners::Minitest.create_collection_file_on_exit = false
               raise
             end
 
           end
+        else
+          raise "Minitest version #{::Minitest::VERSION rescue '?'} not supported."
         end
-        @covet_hooked = true
+        @hooked = true
       end
 
       def self.cmdline_for_run_list(run_list)

data/lib/covet/vcs/git.rb

@@ -18,7 +18,7 @@ module Covet
           # raises Rugged::Error or TypeError if `revision` is invalid Git object id
           # (tag name or sha1, etc.)
           commit = Rugged::Commit.new(repo, revision)
-          repo.index.diff(commit, {}) # NOTE: for some reason, this call doesn't work properly if the second parameter isn't given. Bug in rugged?
+          repo.index.diff(commit, {}) # NOTE: for some reason, this call doesn't work properly if the second argument isn't given. Bug in rugged?
         end
         diff.each_patch { |patch|
           file = patch.delta.old_file[:path] # NOTE: old file is the index's version

data/lib/covet/version.rb

@@ -1,3 +1,3 @@
 module Covet
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.1.1'.freeze
 end

data/spec/rspec_collection_hook_spec.rb

@@ -0,0 +1,12 @@
+require_relative 'spec_helper'
+
+first_logs_size = 0
+RSpec.describe do "Each spec method"
+  it "1. should be wrapped in coverage collection" do
+    first_logs_size = Covet.log_collection.size
+  end
+
+  it "2. should be wrapped in coverage collection" do
+    Covet.log_collection.size.should_not equal(first_logs_size)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,75 @@
+require_relative '../lib/covet'
+require_relative '../test/fakelib'
+gem 'rspec'
+require 'rspec'
+
+Covet.test_runner = :rspec
+Covet::CollectionFilter.whitelist_gem('covet')
+Covet.register_coverage_collection!
+
+module CovetTestHelpers
+
+  def coverage_before_and_after(&block)
+    Covet.coverage_before_and_after(&block)
+  end
+
+  def generate_run_list_for_method(before, after, options = {})
+    Covet.generate_run_list_for_method(before, after, options)
+  end
+
+  def change_file(fname, lineno, new_line) # yields
+    check_file_exists!(fname)
+    new_line << "\n" unless new_line.end_with?("\n")
+    contents = File.read(fname).lines.to_a
+    old_contents = contents.dup
+    old_line = contents[lineno - 1]
+    if old_line.nil?
+      raise ArgumentError, "invalid line number for #{fname}: #{lineno}"
+    end
+    contents[lineno - 1] = new_line
+    File.open(fname, 'w') { |f| f.write contents.join }
+    yield
+  ensure
+    if old_contents
+      File.open(fname, 'w') {|f| f.write old_contents.join }
+    end
+  end
+
+  def remove_file(fname) # yields
+    check_file_exists!(fname)
+    # TODO
+  end
+
+  def rename_file(fname, new_name) # yields
+    check_file_exists!(fname)
+    # TODO
+  end
+
+  def add_file(fname, contents) # yields
+    check_file_doesnt_exist!(fname)
+    # TODO
+  end
+
+  def with_collection_filter(filter) # yields
+    # TODO
+  end
+
+  private
+
+    def check_file_exists!(fname)
+      unless File.exist?(fname)
+        raise ArgumentError, "file doesn't exist: #{fname}"
+      end
+    end
+
+    def check_file_doesnt_exist!(fname)
+      if File.exist?(fname)
+        raise ArgumentError, "file already exists: #{fname}"
+      end
+    end
+
+end
+
+RSpec.configure do |c|
+  c.include CovetTestHelpers
+end

data/test/coverage_peek_result_test.rb

@@ -0,0 +1,34 @@
+require_relative 'test_helper'
+require 'tmpdir'
+
+class CoveragePeekResultTest < CovetTest
+  # Aaron's original test for `Coverage::peek_result` in
+  # https://github.com/ruby/ruby/commit/a86eacf552c0f3a7862d6891cf174007d96f656a
+  def test_coverage_peek_result
+    loaded_features = $".dup
+
+    Dir.mktmpdir {|tmp|
+      Dir.chdir(tmp) {
+        File.open("test.rb", "w") do |f|
+          f.puts <<-EOS
+            def coverage_test_method
+              :ok
+            end
+          EOS
+        end
+        require tmp + '/test.rb'
+        cov = CovetCoverage.peek_result[tmp + '/test.rb']
+        coverage_test_method
+        cov2 = CovetCoverage.peek_result[tmp + '/test.rb']
+        assert_equal cov[1] + 1, cov2[1]
+        begin
+          assert_equal cov2, CovetCoverage.result[tmp + '/test.rb']
+        ensure # `CovetCoverage#result` stops coverage collection
+          CovetCoverage.start
+        end
+      }
+    }
+  ensure
+    $".replace loaded_features
+  end
+end

data/test/fakelib.rb

@@ -0,0 +1,9 @@
+class MyClass
+  def initialize(options = {})
+    super()
+  end
+  def hello?
+    :hi
+  end
+# NOTE: leave this line here, as we use `change_file` to change it during testing
+end

data/test/fakelib2.rb

@@ -0,0 +1,6 @@
+require_relative 'fakelib'
+
+class Fake2
+  def initialize(fake1 = MyClass.new)
+  end
+end

data/test/log_collection_test.rb

@@ -0,0 +1,26 @@
+require_relative 'test_helper'
+require 'tempfile'
+
+class LogCollectionTest < CovetTest
+  @@tempfile = Tempfile.new('test')
+  @@tempfile.close
+
+  def setup
+    @logs = Covet::LogCollection.new(
+      :filename => @@tempfile.path,
+      :bufsize => 20
+    )
+  end
+
+  def test_append_and_finish
+    100.times do |i|
+      @logs << [i]
+    end
+    assert_equal 5, @logs.flushes
+    @logs << [42]
+    assert @logs.finish!
+    assert_equal 6, @logs.flushes
+    assert !File.read(@@tempfile.path).empty?
+  end
+
+end

data/test/log_file_test.rb

@@ -0,0 +1,50 @@
+require_relative 'test_helper'
+require 'tempfile'
+
+class LogFileTest < CovetTest
+  @@tempfile = Tempfile.new('test')
+  @@tempfile.close
+
+  def test_write_buf_uses_index_file
+    index_fname = @@tempfile.path + 'index'
+    logfile = Covet::LogFile.new(
+      :filename => @@tempfile.path,
+      :index_filename => index_fname
+    )
+    logfile.write_start
+    100.times do |i|
+      buf = Array.new(100, i)
+      logfile.write_buf(buf)
+    end
+    logfile.write_end
+    assert_equal 102, logfile.writes
+    ary = logfile.load!
+    assert_equal 100, ary.size
+    assert_equal 100, ary[0].size
+    assert_equal 0, ary[0][0]
+    assert_kind_of Array, ary
+  end
+
+  def test_each_buf_using_index_file
+    index_fname = @@tempfile.path + 'index'
+    logfile = Covet::LogFile.new(
+      :filename => @@tempfile.path,
+      :index_filename => index_fname
+    )
+
+    logfile.write_start
+    100.times do |i|
+      buf = Array.new(100, i)
+      logfile.write_buf(buf)
+    end
+    logfile.write_end
+
+    all_bufs = []
+    logfile.load_each_buf! do |buf|
+      all_bufs << buf
+    end
+    assert_equal 100, all_bufs.size
+    assert all_bufs.all? { |buf| buf.size == 100 }
+  end
+
+end

data/test/minitest_collection_hooks_test.rb

@@ -0,0 +1,19 @@
+require_relative 'test_helper'
+
+class MinitestCollectionHooks < CovetTest
+  @@first_logs = []
+
+  def self.test_order
+    :sorted
+  end
+
+  def test_1_collect_for_next_test
+    @@first_logs = Covet.log_collection.instance_variable_get("@buf").dup
+    # do nothing, assertion(s) are in next test
+  end
+
+  def test_2_log_collection_size_increases_after_test
+    assert Covet.log_collection.size > 0
+    assert Covet.log_collection.size != @@first_logs.size
+  end
+end

data/test/run_list_test.rb

@@ -0,0 +1,32 @@
+require_relative 'test_helper'
+
+class RunListTest < CovetTest
+  def test_empty_run_list_for_method
+    before, after = coverage_before_and_after { }
+    list = generate_run_list_for_method(before, after, :method_name => __method__)
+    assert_equal Hash, list.class
+    methods_to_run = list.values.map(&:values).flatten.uniq
+    assert list.empty? || methods_to_run == [__method__.to_s]
+  end
+
+  def test_non_empty_run_list_for_method_due_to_changed_lib_file
+    obj = MyClass.new
+    assert_equal :hi, obj.hello?
+    fname = File.expand_path('../fakelib.rb', __FILE__)
+
+    before, after = coverage_before_and_after do
+      change_file(fname, 8, "def goodbye; 'bye'; end") do
+        load fname
+      end
+      obj = MyClass.new
+      assert_equal 'bye', obj.goodbye
+    end
+    MyClass.class_eval { undef :goodbye }
+
+    refute_equal before, after
+    list = generate_run_list_for_method(before, after, :method_name => __method__)
+    assert_equal Hash, list.class
+    assert !list.empty?
+    assert list[fname]
+  end
+end

data/test/skips_test.rb

@@ -0,0 +1,23 @@
+require_relative 'test_helper'
+
+class SkipsTest < CovetTest
+  def self.test_order
+    :sorted
+  end
+
+  @@collections = nil
+
+  def setup
+    # ... do nothing. Don't call `super` to make sure coverage information isn't cleared before each new test
+  end
+
+  def test_1_skip
+    @@collections = Covet.log_collection.instance_variable_get("@buf").dup
+    skip 'for next test'
+  end
+
+  def test_2_skips_dont_update_coverage_collection
+    assert_equal @@collections, Covet.log_collection.instance_variable_get("@buf")
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,88 @@
+require_relative '../lib/covet'
+require_relative 'fakelib'
+gem 'minitest'
+begin
+  require 'minitest' # minitest 5
+  Minitest.autorun
+rescue LoadError
+  require 'minitest/unit' # minitest 4
+  require 'minitest/autorun'
+end
+
+Covet::CollectionFilter.whitelist_gem('covet')
+Covet.register_coverage_collection!
+
+class CovetTest < defined?(Minitest::Test) ? Minitest::Test : Minitest::Unit::TestCase
+
+  def setup
+    Covet::BASE_COVERAGE.update({})
+  end
+
+  def coverage_before_and_after(&block)
+    Covet.coverage_before_and_after(&block)
+  end
+
+  def generate_run_list_for_method(before, after, options = {})
+    Covet.generate_run_list_for_method(before, after, options)
+  end
+
+  def change_file(fname, lineno, new_line) # yields
+    check_file_exists!(fname)
+    new_line << "\n" unless new_line.end_with?("\n")
+    contents = File.read(fname).lines.to_a
+    old_contents = contents.dup
+    old_line = contents[lineno - 1]
+    if old_line.nil?
+      raise ArgumentError, "invalid line number for #{fname}: #{lineno}"
+    end
+    contents[lineno - 1] = new_line
+    File.open(fname, 'w') do |f|
+      f.write contents.join
+    end
+    yield
+  ensure
+    if old_contents
+      File.open(fname, 'w') do |f|
+        f.write old_contents.join
+      end
+    end
+  end
+
+  def method_in_coverage_info?(info, method)
+    # TODO
+  end
+
+  def remove_file(fname) # yields
+    check_file_exists!(fname)
+    # TODO
+  end
+
+  def rename_file(fname, new_name) # yields
+    check_file_exists!(fname)
+    # TODO
+  end
+
+  def add_file(fname, contents) # yields
+    check_file_doesnt_exist!(fname)
+    # TODO
+  end
+
+  def with_collection_filter(filter) # yields
+    # TODO
+  end
+
+  private
+
+    def check_file_exists!(fname)
+      unless File.exist?(fname)
+        raise ArgumentError, "file doesn't exist: #{fname}"
+      end
+    end
+
+    def check_file_doesnt_exist!(fname)
+      if File.exist?(fname)
+        raise ArgumentError, "file already exists: #{fname}"
+      end
+    end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: covet
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Luke Gruber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-15 00:00:00.000000000 Z
+date: 2016-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rugged
@@ -38,6 +38,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: wwtd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Uses git and ruby coverage information to determine which tests to run
   from your test suite
 email: luke.gru@gmail.com
@@ -47,16 +75,23 @@ extensions:
 - ext/covet_coverage/extconf.rb
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - README.md
 - Rakefile
 - bin/covet
 - ext/covet_coverage/covet_coverage.c
 - ext/covet_coverage/extconf.rb
+- gemfiles/minitest4-0-0.gemfile
+- gemfiles/minitest5-0-8.gemfile
+- gemfiles/minitest5-3-3.gemfile
+- gemfiles/minitest5-7-0.gemfile
 - lib/covet.rb
 - lib/covet/cli.rb
 - lib/covet/collection_compressor.rb
 - lib/covet/collection_filter.rb
+- lib/covet/collection_task.rb
 - lib/covet/line_changes_vcs.rb
 - lib/covet/log_collection.rb
 - lib/covet/log_file.rb
@@ -65,7 +100,18 @@ files:
 - lib/covet/vcs/git.rb
 - lib/covet/version.rb
 - lib/covet_collect.rb
-homepage: 
+- spec/rspec_collection_hook_spec.rb
+- spec/spec_helper.rb
+- test/coverage_peek_result_test.rb
+- test/fakelib.rb
+- test/fakelib2.rb
+- test/log_collection_test.rb
+- test/log_file_test.rb
+- test/minitest_collection_hooks_test.rb
+- test/run_list_test.rb
+- test/skips_test.rb
+- test/test_helper.rb
+homepage: https://github.com/luke-gru/covet
 licenses:
 - MIT
 metadata: {}
@@ -85,8 +131,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Regression test selection tool based on coverage information
-test_files: []
+test_files:
+- test/log_collection_test.rb
+- test/skips_test.rb
+- test/fakelib.rb
+- test/run_list_test.rb
+- test/test_helper.rb
+- test/coverage_peek_result_test.rb
+- test/log_file_test.rb
+- test/fakelib2.rb
+- test/minitest_collection_hooks_test.rb
+- spec/spec_helper.rb
+- spec/rspec_collection_hook_spec.rb