mattwynne-cucover 0.0.4 → 0.1.0

data/lib/cucover/recording/covered_file.rb

@@ -0,0 +1,53 @@
+module Cucover
+  class Recording::CoveredFile
+    attr_reader :file
+    
+    def initialize(full_filename, rcov_marked_info, recording)
+      @full_filename    = full_filename
+      @rcov_marked_info = rcov_marked_info
+      @recording        = recording
+      @file = File.expand_path(full_filename).gsub(/^#{Dir.pwd}\//, '')
+      
+      extend HasLineNumberDetail if @rcov_marked_info
+    end
+    
+    def dirty?
+      Cucover.logger.debug("#{file}     last modified at #{File.mtime(@full_filename)}")
+      Cucover.logger.debug("#{file} recording started at #{@recording.start_time}")
+      result = File.mtime(@full_filename).to_i >= @recording.start_time.to_i
+      Cucover.logger.debug("verdict: #{(result ? "dirty" : "not dirty")}")
+      result
+    end
+    
+    def covers_line?(line_number)
+      covered_lines.include?(line_number)
+    end
+    
+    def ==(other)
+      other == file
+    end
+    
+    def to_s
+      "#{file}:#{covered_lines.join(':')}"
+    end
+    
+    private
+    
+    def covered_lines
+      ['<unknown lines>']
+    end
+    
+    module HasLineNumberDetail
+      def covered_lines
+        return @covered_lines if @covered_lines
+        
+        @covered_lines = []
+        @rcov_marked_info.each_with_index do |covered, index|
+          line_number = index + 1
+          @covered_lines << line_number if covered
+        end
+        @covered_lines
+      end
+    end
+  end
+end

data/lib/cucover/recording.rb

@@ -0,0 +1,64 @@
+module Cucover
+  class Recording < Struct.new(
+      :file_colon_line, 
+      :exception, 
+      :additional_covered_files, 
+      :analyzer, 
+      :start_time, :end_time)
+    
+    def feature_filename
+      file_colon_line.split(':').first
+    end
+    
+    def covers_file?(source_file)
+      covered_files.include?(source_file)
+    end
+    
+    def covers_line?(source_file, line_number)
+      covered_files.detect{ |f| f.file == source_file }.covers_line?(line_number)
+    end
+    
+    def covered_files
+      @covered_files ||= analyzed_covered_files + additional_covered_files
+    end
+    
+    def failed?
+      !!exception
+    end
+    
+    private
+    
+    def additional_covered_files
+      super.map do |filename|
+        CoveredFile.new(filename, nil, self)
+      end
+    end
+    
+    def analyzed_covered_files
+      filtered_analyzed_files.map do |filename| 
+        lines, marked_info, count_info = analyzer.data(filename)
+        CoveredFile.new(filename, marked_info, self)
+      end
+    end
+    
+    def boring?(file)
+      [
+        /gem/,
+        /vendor/,
+        /lib\/ruby/,
+        /cucover/
+      ].any? do |expression|
+        file.match expression
+      end
+    end
+    
+    def filtered_analyzed_files
+      analyzer.analyzed_files.reject{ |f| boring?(f) }
+    end
+
+    def normalized_files
+      cleaned_analyzed_files + additional_covered_files
+    end
+  end
+end
+require 'cucover/recording/covered_file'

data/lib/cucover/store.rb

@@ -0,0 +1,70 @@
+module Cucover
+  class Store
+    def initialize(cache = DiskCache.new)
+      @cache = cache
+    end
+    
+    def latest_recordings
+      recordings.keys.map{ |file_colon_line| latest_recording(file_colon_line) }
+    end
+  
+    def latest_recording(file_colon_line)
+      recordings[file_colon_line].sort{ |x, y| x.end_time <=> y.end_time }.last
+    end
+  
+    def keep!(recording_data)
+      Cucover.logger.debug("Storing recording of #{recording_data.file_colon_line}")
+      recordings[recording_data.file_colon_line] << recording_data
+      @cache.save(@recordings)
+    end
+  
+    def recordings_covering(source_file)
+      latest_recordings.select { |r| r.covers_file?(source_file) }
+    end
+  
+    def recordings
+      ensure_recordings_loaded!
+      @recordings
+    end
+  
+    private
+  
+    def ensure_recordings_loaded!
+      return if @recordings
+      
+      if @recordings = @cache.load
+        Cucover.logger.debug("Loaded #{@recordings.length} recording(s)")
+      else
+        Cucover.logger.debug("Starting with no existing coverage data.")
+        @recordings = Recordings.new
+      end
+    end
+    
+    class Recordings < Hash
+      def [](key)
+        self[key] = [] if super.nil?
+        super
+      end        
+    end
+    
+    class DiskCache
+      def save(recordings)
+        Cucover.logger.debug("Saving #{recordings.length} recording(s) to #{data_file}")
+        File.open(data_file, 'w') { |f| f.puts Marshal.dump(recordings) }
+      end
+      
+      def load
+        return unless File.exists?(data_file)
+        
+        Cucover.logger.debug("Reading existing coverage data from #{data_file}")
+        File.open(data_file) { |f| Marshal.load(f) }
+      end
+      
+      private
+      
+      def data_file
+        Dir.pwd + '/cucover.data'
+      end
+    end
+  end
+end

data/lib/cucover.rb

@@ -1,237 +1,60 @@
-
-require 'rubygems'
-
-gem 'cucumber', '>=0.3'
-require 'cucumber'
-
-gem 'spicycode-rcov', '>=0.8.1.5.0'
-require 'rcov'
-require 'spec'
-
 $:.unshift(File.dirname(__FILE__)) 
+require 'dependencies'
+require 'cucover/logging_config'
+require 'cucover/cli_commands/coverage_of'
+require 'cucover/cli_commands/cucumber'
+require 'cucover/cli_commands/show_recordings'
+require 'cucover/controller'
+require 'cucover/cli'
 require 'cucover/monkey'
 require 'cucover/rails'
+require 'cucover/recording'
+require 'cucover/recorder'
+require 'cucover/store'
 
 module Cucover
-  
-  class TestRun
-    def initialize(feature_file, visitor)
-      @feature_file, @visitor = feature_file, visitor
-    end
-    
-    def record(source_file)
-      additional_covered_files << source_file
-    end
-    
-    def fail!
-      @failed = true
-    end
-    
-    def watch
-      announce_skip unless may_execute?
-
-      analyzer.run_hooked do
-        yield
-      end
-      
-      record(@feature_file)
-      source_files_cache.save analyzed_files
-      status_cache.record(status)
-    end
-    
-    def may_execute?
-      dirty? || failed_on_last_run?
-    end
-    
-    private
-    
-    def status
-      @failed ? :failed : :passed
-    end
-    
-    def additional_covered_files
-      @additional_covered_files ||= []
-    end
-    
-    def announce_skip
-      messages = []
-      messages << "Cucover - Skipping clean feature"
-      messages << "Last run status: #{status_cache.last_run_status}"
-      @visitor.announce messages.flatten.map{ |m| "[ #{m.rstrip} ]"}.join("\n")
-    end
-    
-    def failed_on_last_run?
-      return false unless status_cache.exists?
-      status_cache.last_run_status == "failed"
-    end
-    
-    def dirty?
-      return true unless source_files_cache.exists?
-      source_files_cache.any_dirty_files?
+  class << self
+    def logger
+      Logging::Logger['Cucover']
     end
     
-    def source_files_cache
-      @source_files_cache ||= SourceFileCache.new(@feature_file)
+    def should_execute?(scenario_or_table_row)
+      controller(scenario_or_table_row).should_execute?
     end
     
-    def status_cache
-      @status_cache ||= StatusCache.new(@feature_file)
-    end
+    def start_recording!(scenario_or_table_row)
+      raise("Already recording. Please call stop first.") if recording?
 
-    def source_files
-      analyzed_files
+      @current_recorder = Recorder.new(scenario_or_table_row)
+      @current_recorder.start!
+      record_file(scenario_or_table_row.file_colon_line.split(':').first) # TODO: clean this by extending the feature element
     end
-    
-    def analyzed_files
-      normalized_files.reject{ |f| boring?(f) }.sort
-    end
-    
-    def normalized_files
-      (analyzer.analyzed_files + additional_covered_files.uniq).map{ |f| File.expand_path(f).gsub(/^#{Dir.pwd}\//, '') }
-    end
-    
-    def boring?(file)
-      return false
-      (file.match /gem/) || (file.match /vendor/) || (file.match /lib\/ruby/)
-    end
-    
-    def analyzer
-      @analyzer ||= Rcov::CodeCoverageAnalyzer.new      
-    end
-    
-  end
-  
-  class << self
-    def start_test(test, visitor) 
-      @current_test = TestRun.new(test.file, visitor)
 
-      @current_test.watch do
-        yield
-      end
-    end
-    
-    def fail_current_test!
-      current_test.fail!
-    end
-    
-    def record(source_file)
-      current_test.record(source_file)
-    end
-    
-    def should_skip?
-      not current_test.may_execute?
-    end
-    
-    private
-    
-    def current_test
-      @current_test or raise("You need to start the a test first!")
-    end
-  end
-  
-  class Cache
-    def initialize(feature_file)
-      @feature_file = feature_file
-    end    
-    
-    def exists?
-      File.exist?(cache_filename)
-    end
-    
-    def cache_filename
-      @feature_file.gsub /([^\/]*\.feature)/, '.coverage/\1'
-    end
-    
-    def time
-      File.mtime(cache_filename)
-    end
+    def stop_recording!
+      return unless recording?
 
-    def write_to_cache
-      FileUtils.mkdir_p File.dirname(cache_filename)
-      File.open(cache_filename, "w") do |file|
-        yield file
-      end
-    end
-  end
-  
-  class StatusCache < Cache
-    def last_run_status
-      File.open(cache_filename, "r") do |file|
-        file.each_line do |line|
-          return line.strip
-        end
-      end
+      @current_recorder.stop!
+      store.keep!(@current_recorder.recording)
+      @current_recorder = nil
     end
     
-    def record(status)
-      write_to_cache do |file|
-        file.puts status
-      end
-    end
-    
-    private
-
-    def cache_filename
-      super + '.status'
+    def record_file(source_file)
+      Cucover.logger.debug("Recording extra source file #{source_file}")
+      @current_recorder.record_file!(source_file)
     end
-  end
   
-  class SourceFileCache < Cache
-    def save(analyzed_files)
-      write_to_cache do |file|
-        file.puts analyzed_files
-      end
-    end
-    
-    def any_dirty_files?
-      not dirty_files.empty?
-    end
-    
-    def source_files
-      result = []
-      File.open(cache_filename, "r") do |file|
-        file.each_line do |line|
-          result.push line
-        end
-      end
-      result
-    end
-
     private
-
-    def dirty_files
-      source_files.select do |source_file|
-        File.mtime(source_file.strip) >= time
-      end
-    end
     
-  end
-  
-  module LazyStepInvocation
-    def accept(visitor)
-      skip_invoke! if Cucover.should_skip?
-      super
+    def controller(scenario_or_table_row)
+      Controller.new(scenario_or_table_row.file_colon_line, store)
     end
     
-    def failed(exception, clear_backtrace)
-      Cucover.fail_current_test!
-      super
+    def recording?
+      !!@current_recorder
     end
-  end
   
-  module LazyFeature
-    def accept(visitor)
-      Cucover.start_test(self, visitor) do
-        super
-      end
+    def store
+      @store ||= Store.new
     end
-    
-  end
-end
-
-Cucover::Monkey.extend_every Cucumber::Ast::Feature => Cucover::LazyFeature
-Cucover::Monkey.extend_every Cucumber::Ast::StepInvocation => Cucover::LazyStepInvocation
-
-Before do
-  Cucover::Rails.patch_if_necessary
+  end  
 end

data/lib/dependencies.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+
+gem 'cucumber', '>=0.3.1'
+require 'cucumber'
+
+gem 'spicycode-rcov', '>=0.8.1.5.0'
+require 'rcov'
+require 'spec'
+
+require 'logging'

data/spec/cucover/cli_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Cucover::Cli do
+  describe "given a --coverage-of command" do
+    before(:each) do
+      @args = ['--coverage-of', 'lib/foo.rb']
+    end
+    
+    it "should create a CoverageOf command object and execute it" do
+      Cucover::CliCommands::CoverageOf.should_receive(:new).with(['--coverage-of', 'lib/foo.rb']).and_return(command = mock('command'))
+      command.should_receive(:execute)
+      cli = Cucover::Cli.new(@args)
+      cli.start
+    end
+  end
+  
+  describe "given arguments for Cucumber" do
+    before(:each) do
+      @args = ['--', 'c', 'd']
+    end
+    it "should pass the arguments after the -- to cucumber" do
+      cli = Cucover::Cli.new(@args)
+    
+      Kernel.stub!(:load).with(Cucumber::BINARY) do
+        ARGV.should == ['c', 'd']
+      end
+    
+      cli.start
+    end
+  end
+end

data/spec/cucover/controller_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module Cucover
+  describe Controller do
+    describe "#should_execute?" do
+      before(:each) do
+        @store = mock(Store)
+        @example_id = 'foo.feature:123'
+      end
+      it "when no previous recording exists, it should always return true" do
+        @store.should_receive(:latest_recording).with(@example_id).and_return(nil)
+        Controller.new(@example_id, @store).should_execute?.should be_true
+      end
+    end
+  end
+end

data/spec/cucover/recording/covered_file_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+class Cucover::Recording
+  describe CoveredFile do
+    describe "with a marked info" do
+      before(:each) do
+        @recording = mock('Recording')
+        @covered_file = CoveredFile.new("foo.rb", [true, true, false], @recording)        
+      end
+      
+      it "should set the covered_lines correctly from the marked info" do
+        [1,2].each do |line_number|
+          @covered_file.covers_line?(line_number).should be_true
+        end
+        
+        @covered_file.covers_line?(3).should be_false
+      end
+    end
+  end
+end

data/spec/cucover/store_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module Cucover
+  describe Store do
+    before(:each) do
+      @cache = mock('cache', :load => nil)
+      @store = Store.new(@cache)
+    end
+    describe "#latest_recording" do
+      it "should return nil if no recordings match the given identifier" do
+        @store.latest_recording('blah:234').should be_nil
+      end
+      
+      describe "when multiple recordings match the given indentifier" do
+        before(:each) do
+          old_recording = mock('old data', :end_time => Time.now - 200)
+          @new_recording = mock('new data', :end_time => Time.now)
+          @cache.stub!(:load).and_return({
+            'foo.feature:33' => [ old_recording, @new_recording ] 
+          })
+        end
+        it "should return the one with the latest end_time" do
+          @store.latest_recording('foo.feature:33').should == @new_recording
+        end        
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+gem 'rspec'
+require 'spec'
+require 'spec/mocks/framework'
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'cucover'