mattwynne-cucover 0.0.2 → 0.0.3

data/README.markdown

@@ -10,11 +10,14 @@ How does it decide whether it needs to run a feature? Every time you run a featu
 
   * Uses RCov to map features to covered source files
   * Patches Rails to also map features to covered .erb templates
+  * Shows skipped Scenarios, for confidence
+  * Re-runs failing features, even when nothing has changed, for that good old red-bar feel.
 
 ## Installation and Usage
 
 Something like this, as I haven't figured out the dependencies yet for the gem:
 
+    sudo gem install cucumber
     sudo gem install spicycode-rcov
     sudo gem install mattwynne-cucover
 
@@ -26,8 +29,10 @@ To run your features lazily, just use the cucover binary instead of cucumber. Us
   * This is very new and experimental. There may be bugs. Feedback is welcome via github messages.
 
 ## Todo
-  * The features for cucuover itself seem to flicker (intermittently fail). This is probably due to timing issues when figuring out if a file is dirty.
-  * Consider making failing features run-run even when they're not dirty, just for the good old red-bar feel
+  * One or two of the features for Cucuover itself seem to flicker (intermittently fail). This is probably due to timing issues when figuring out if a file is dirty.
+  * Make laziness work down to the granularity of scenarios, rather than features
+  * I suspect it does wierd things if you pass more than one visitor. Need to test for this.
+  * Speed up the Rails test - maybe strip some guff out of the environment load?
     
 ## Similar 'Selective Testing' Tools
 
@@ -45,4 +50,3 @@ To run your features lazily, just use the cucover binary instead of cucumber. Us
   * JUnitMax
     * a selective testing tool by [Kent Beck](http://www.threeriversinstitute.org/blog)
     * http://junitmax.com/
-

data/bin/cucover

@@ -1,5 +1,3 @@
 #!/usr/bin/env ruby
-require 'rubygems'
-require 'cucumber'
 require File.expand_path(File.dirname(__FILE__) + '../../lib/cucover')
 load Cucumber::BINARY

data/lib/cucover.rb

@@ -1,92 +1,81 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 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 'cucover/monkey'
+require 'cucover/rails'
 
 module Cucover
   
-  class << self
-    def record(file)
-      additional_covered_files << file
-    end
-    def additional_covered_files
-      @additional_covered_files ||= []
-    end
-  end
-  
-  class SourceFileCache
-    def initialize(feature_file)
-      @feature_file = feature_file
+  class TestRun
+    def initialize(feature_file, visitor)
+      @feature_file, @visitor = feature_file, visitor
     end
     
-    def save(analyzed_files)
-      FileUtils.mkdir_p File.dirname(cache_filename)
-      File.open(cache_filename, "w") do |file|
-        file.puts analyzed_files
-      end
+    def record(source_file)
+      additional_covered_files << source_file
     end
     
-    def exists?
-      File.exist?(cache_filename)
+    def fail!
+      @failed = true
     end
     
-    def any_dirty_files?
-      not dirty_files.empty?
+    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 time
-      File.mtime(cache_filename)
+    def may_execute?
+      dirty? || failed_on_last_run?
     end
-
+    
     private
-
-    def dirty_files
-      source_files.select do |source_file|
-        File.mtime(Dir.pwd + '/' + source_file.strip) >= time
-      end
+    
+    def status
+      @failed ? :failed : :passed
     end
     
-    def source_files
-      result = []
-      File.open(cache_filename, "r") do |file|
-        file.each_line do |line|
-          result.push line
-        end
-      end
-      result
+    def additional_covered_files
+      @additional_covered_files ||= []
     end
     
-    def cache_filename
-      @feature_file.gsub /([^\/]*\.feature)/, '.coverage/\1'
+    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
-  end
-  
-  module LazyFeature
     
-    def accept(visitor)
-      return unless dirty?
-      Cucover.additional_covered_files.clear
-      analyzer.run_hooked do
-        super
-      end
-      source_files_cache.save analyzed_files
+    def failed_on_last_run?
+      return false unless status_cache.exists?
+      status_cache.last_run_status == "failed"
     end
-
-    private
     
     def dirty?
       return true unless source_files_cache.exists?
-      return true if changed_since_last_run?
       source_files_cache.any_dirty_files?
     end
     
-    def changed_since_last_run?
-      File.mtime(@file) >= source_files_cache.time
-    end
-
     def source_files_cache
-      @source_files_cache ||= SourceFileCache.new(@file)
+      @source_files_cache ||= SourceFileCache.new(@feature_file)
+    end
+    
+    def status_cache
+      @status_cache ||= StatusCache.new(@feature_file)
     end
 
     def source_files
@@ -98,61 +87,151 @@ module Cucover
     end
     
     def normalized_files
-      (analyzer.analyzed_files + Cucover.additional_covered_files.uniq).map{ |f| File.expand_path(f).gsub(/^#{Dir.pwd}\//, '') }
+      (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
   
-  module LazyFeatures
-    def add_feature(feature)
-      super feature.extend(LazyFeature)
+  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 write_to_cache
+      FileUtils.mkdir_p File.dirname(cache_filename)
+      File.open(cache_filename, "w") do |file|
+        yield file
+      end
     end
   end
   
-  module Rails
-    class << self
-      def patch_if_necessary
-        return if @patched
-        return unless defined?(ActionView)
-        
-        ActionView::Template.instance_eval do
-          def new(*args)
-            super(*args).extend(Cucover::Rails::RecordsRenders)
-          end
+  class StatusCache < Cache
+    def last_run_status
+      File.open(cache_filename, "r") do |file|
+        file.each_line do |line|
+          return line.strip
         end
-        
-        @patched = true
       end
     end
     
-    module RecordsRenders
-      def render
-        Cucover.record(@filename)
-        super
+    def record(status)
+      write_to_cache do |file|
+        file.puts status
       end
     end
-  end
-end
+    
+    private
 
-module Cucumber
-  module Ast
-    class Features
-      class << self
-        def new(*args)
-          super(*args).extend(Cucover::LazyFeatures)
+    def cache_filename
+      super + '.status'
+    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
+    end
+    
+    def failed(exception, clear_backtrace)
+      Cucover.fail_current_test!
+      super
+    end
+  end
+  
+  module LazyFeature
+    def accept(visitor)
+      Cucover.start_test(self, visitor) do
+        super
+      end
     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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mattwynne-cucover
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Matt Wynne