covet 0.1.0

data/lib/covet/log_file.rb

@@ -0,0 +1,164 @@
+require 'json'
+
+module Covet
+  # Represents log file of JSON coverage information for each test method.
+  # For each write of a memory buffer to disk, a separate index file keeps track
+  # of the file offset and bytes written for the buffer. This is so that when
+  # there lots of tests in a test suite, we don't have to keep all coverage
+  # information in memory. Instead, we flush the information and write it to
+  # 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)
+
+    attr_reader :name, :writes
+
+    def initialize(options = {})
+      @mode = options[:mode] || 'w'
+      @name = options[:filename] || File.join(Dir.pwd, 'run_log.json')
+      if @mode != 'r'
+        # We only want to create the real file during the `write_end` method, so write to
+        # a tempfile until then. This is in case the user stops their test suite with an
+        # interrupt.
+        @tmpfile = Tempfile.new(File.basename(@name))
+        @tmpname = @tmpfile.path
+      else
+        @tmpfile = nil
+        @tmpname = nil
+      end
+      @index_file = LogFileIndex.new(:filename => options[:index_filename])
+      @writes = 0
+    end
+
+    def write_start
+      check_can_write!
+      @tmpfile.write('[')
+      @writes += 1
+    end
+
+    def write_buf(buf)
+      check_can_write!
+      pos_start = @tmpfile.pos
+      @tmpfile.write(JSON.dump(buf) + ',')
+      @writes += 1
+      pos_after = @tmpfile.pos
+      @index_file.add_index(pos_start, pos_after - pos_start)
+    end
+
+    def write_end
+      check_can_write!
+      @tmpfile.pos -= 1 # remove final comma at end of array
+      @tmpfile.write(']')
+      @writes += 1
+      @tmpfile.close
+      FileUtils.cp(@tmpfile, @name)
+      @index_file.finish!
+    end
+
+    def load!
+      JSON.load(File.read(@name))
+    end
+
+    # Yields each coverage buffer (Array) one a time from the run log.
+    # @raises LogFile::LoadError
+    def load_each_buf! # yields
+      @index_file.reload!('r')
+      reload!('r')
+      index = JSON.load(File.read(@index_file.name))
+      index.each do |(pos, bytes_to_read)|
+        res = load_buf_from_file!(pos, bytes_to_read)
+        yield res # @var Array
+      end
+    end
+
+    # @raises LogFile::LoadError
+    # @return Array
+    def load_buf!(buf_idx)
+      @index_file.reload!('r')
+      reload!('r')
+      index = JSON.load(File.read(@index_file.name))
+      pos, bytes_to_read = index[buf_idx]
+      load_buf_from_file!(pos, bytes_to_read)
+    end
+
+    # @raises LogFile::LoadError
+    # @return Hash
+    def load_run_stats!
+      load_buf!(-1).last[-1]
+    end
+
+    def file_exists?
+      File.exist?(@name)
+    end
+
+    # re-opens file, can raise Errno::ENOENT
+    def reload!(mode)
+      if @file && !@file.closed?
+        @file.close
+      end
+      @file = File.open(@name, mode)
+    end
+
+    private
+
+      def file
+        @file ||= File.open(@name, @mode)
+      end
+
+      def check_can_write!
+        if @mode == 'r'
+          raise "For writing to the log file, you must construct it with a different :mode"
+        end
+      end
+
+      # @raises LogFile::LoadError
+      # @return Array
+      def load_buf_from_file!(pos, bytes_to_read)
+        file.pos = pos
+        buf = file.read(bytes_to_read)
+        if buf.end_with?(',', ']]')
+          buf = buf[0..-2]
+        end
+        JSON.load(buf)
+      rescue JSON::ParserError => e
+        raise LogFile::LoadError, e.message
+      end
+
+  end
+
+  class LogFileIndex
+    attr_reader :name
+
+    def initialize(options = {})
+      @name = options[:filename] || File.join(Dir.pwd, 'run_log_index.json')
+      @index = []
+    end
+
+    def add_index(offset, bytes_written)
+      @index << [offset, bytes_written]
+    end
+
+    def finish!
+      if @index.size > 0
+        file.write(JSON.dump(@index))
+        file.close
+      end
+    end
+
+    def reload!(mode)
+      if @file && !@file.closed?
+        @file.close
+      end
+      @file = File.open(@name, mode)
+    end
+
+    private
+
+      def file
+        @file ||= File.open(@name, 'w')
+      end
+  end
+end

data/lib/covet/test_runners/minitest.rb

@@ -0,0 +1,159 @@
+require 'rake/testtask'
+
+module Covet
+  module TestRunners
+    module Minitest
+      @covet_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
+          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
+        end
+
+        ::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
+                # 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,
+                  :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
+
+              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 even on interrupt :(
+            rescue Interrupt
+              Covet::TestRunners::Minitest.create_collection_file_on_exit = false
+              raise
+            end
+
+          end
+        end
+        @covet_hooked = true
+      end
+
+      def self.cmdline_for_run_list(run_list)
+        files = run_list.map { |double| double[1].split('#').first }
+        files.uniq!
+
+        files_str = files.map { |fname| %Q("#{fname}") }.join(' ')
+        rake_testtask = Rake::TestTask.new
+        rake_loader_str = rake_testtask.rake_loader
+        rake_include_arg = %Q(-I"#{rake_testtask.rake_lib_dir}")
+
+        cmd = %Q(ruby -I"test" -I"lib" #{rake_include_arg} "#{rake_loader_str}" ) +
+          files_str
+
+        unless Covet.options[:disable_test_method_filter]
+          test_methods = run_list.map { |double| double[1].split('#').last }
+          test_methods.uniq!
+          test_methods_regex = Regexp.union(test_methods)
+          cmd << %Q( "-n #{test_methods_regex.inspect}")
+        end
+        cmd
+      end
+    end
+  end
+end

data/lib/covet/test_runners/rspec.rb

@@ -0,0 +1,92 @@
+module Covet
+  module TestRunners
+    module Rspec
+      @hooked = false
+      @run_num = 0
+      @skips = 0
+      @failures = 0
+
+      def self.hook_into_test_methods!
+        if @hooked
+          warn "Warning - Covet.register_coverage_collection! called multiple times"
+          return
+        end
+        gem 'rspec'
+        require 'rspec'
+
+        ::RSpec.configuration.after(:suite) do
+          Covet.log_collection.finish!
+        end
+
+        run_num = @run_num
+        skips = @skips
+        failures = @failures
+
+        ::RSpec.configuration.around(:each) do |test|
+          if run_num == 0
+            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 properly work.\nIf it isn't already, try " \
+                "adding\n  require 'covet'\nas the first thing in 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]
+          end
+
+          run_num += 1
+          before = CovetCoverage.peek_result
+          test.call
+          rspec_metadata = test.metadata
+
+          # TODO: figure out if failed or skipped, and break out of block if it did
+          #
+          # XXX: is this right for all recent versions of rake?
+          file = rspec_metadata[:file_path].sub(%r{\A\./}, '') # remove leading './'
+          line = rspec_metadata[:line_number]
+
+          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, after_orig)
+          if 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}:#{line}", after]
+        end
+        @hooked = true
+      end
+
+      def self.cmdline_for_run_list(run_list)
+        require 'rspec/core/rake_task'
+        files = run_list.map { |double| double[1] }
+        files.uniq!
+        file_list = files.join(' ')
+        old_spec_env = ENV['SPEC']
+        begin
+          ENV['SPEC'] = file_list
+          rspec_rake_task = RSpec::Core::RakeTask.new(:spec) do |t|
+          end
+        ensure
+          ENV['SPEC'] = old_spec_env
+        end
+        # XXX: is this right for all recent versions of rake?
+        # TODO: try to figure out how to get test method names
+        rspec_rake_task.send(:spec_command)
+      end
+    end
+  end
+end

data/lib/covet/vcs/git.rb

@@ -0,0 +1,62 @@
+module Covet
+  module VCS
+    module Git
+      require 'set'
+      require 'rugged'
+
+      # Find lines in git-indexed files that were changed (added/deleted/modified)
+      # in the codebase since `revision`.
+      # @raise Rugged::Error, Rugged::InvalidError, TypeError
+      # @return Set<Array>
+      def self.changes_since(revision = :last_commit)
+        repo = Rugged::Repository.new(find_git_repo_path!) # raises if can't find git repo
+        lines_to_run = Set.new
+        diff = case revision.to_s
+        when 'last_commit', 'HEAD'
+          repo.index.diff
+        else
+          # 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?
+        end
+        diff.each_patch { |patch|
+          file = patch.delta.old_file[:path] # NOTE: old file is the index's version
+
+          patch.each_hunk { |hunk|
+            hunk.each_line { |line|
+              case line.line_origin
+              when :addition
+                lines_to_run << [file, line.new_lineno]
+              when :deletion
+                lines_to_run << [file, line.old_lineno]
+              when :context
+                lines_to_run << [file, line.new_lineno]
+              end
+            }
+          }
+        }
+        lines_to_run
+      end
+
+      # find git repository path at or below `Dir.pwd`
+      def self.find_git_repo_path!
+        dir = orig_dir = Dir.pwd
+        found = Dir.exist?('.git') && dir
+        while !found && dir && Dir.exist?(dir)
+          old_dir = Dir.pwd
+          Dir.chdir('..')
+          dir = Dir.pwd
+          return if old_dir == dir # at root directory
+          if dir && Dir.exist?('.git')
+            found = dir
+          end
+        end
+        found
+      ensure
+        Dir.chdir(orig_dir) if Dir.pwd != orig_dir
+      end
+
+    end
+  end
+end