mislav-rspactor 0.3.2 → 0.3.3

data/Rakefile

@@ -1,38 +1,57 @@
-begin
-  require 'jeweler'
-  
-  Jeweler.class_eval do
-    protected
-    
-    def fill_in_gemspec_defaults(gemspec)
-      if gemspec.files.nil? || gemspec.files.empty?
-        gemspec.files = FileList['Rakefile', '{bin,lib,images,spec}/**/*', 'README*', 'LICENSE*']
-      end
+task :default => :spec
 
-      if gemspec.executables.nil? || gemspec.executables.empty?
-        gemspec.executables = Dir["#{@base_dir}/bin/*"].map do |f|
-          File.basename(f)
-        end
-      end
+desc "starts RSpactor"
+task :spec do
+  system "ruby -Ilib bin/rspactor"
+end
 
-      gemspec
-    end
-  end
-  
-  Jeweler::Tasks.new do |gem|
+desc "generates .gemspec file"
+task :gemspec => "version:read" do
+  spec = Gem::Specification.new do |gem|
     gem.name = "rspactor"
     gem.summary = "RSpactor is a command line tool to automatically run your changed specs (much like autotest)."
     gem.email = "mislav.marohnic@gmail.com"
     gem.homepage = "http://github.com/mislav/rspactor"
     gem.authors = ["Mislav Marohnić", "Andreas Wolff", "Pelle Braendgaard"]
     gem.has_rdoc = false
+    
+    gem.version = GEM_VERSION
+    gem.files = FileList['Rakefile', '{bin,lib,images,spec}/**/*', 'README*', 'LICENSE*']
+    gem.executables = Dir['bin/*'].map { |f| File.basename(f) }
+  end
+  
+  spec_string = spec.to_ruby
+  
+  begin
+    Thread.new { eval("$SAFE = 3\n#{spec_string}", binding) }.join 
+  rescue
+    abort "unsafe gemspec: #{$!}"
+  else
+    File.open("#{spec.name}.gemspec", 'w') { |file| file.write spec_string }
   end
-rescue LoadError
-  puts "Jeweler gem (technicalpickles-jeweler) not found"
 end
 
-task :spec do
-  system 'ruby -Ilib bin/rspactor'
+task :bump => ["version:bump", :gemspec]
+
+namespace :version do
+  task :read do
+    unless defined? GEM_VERSION
+      GEM_VERSION = File.read("VERSION")
+    end
+  end
+  
+  task :bump => :read do
+    if ENV['VERSION']
+      GEM_VERSION.replace ENV['VERSION']
+    else
+      GEM_VERSION.sub!(/\d+$/) { |num| num.to_i + 1 }
+    end
+    
+    File.open("VERSION", 'w') { |v| v.write GEM_VERSION }
+  end
 end
 
-task :default => :spec
+task :release => :bump do
+  system %(git commit VERSION *.gemspec -m "release v#{GEM_VERSION}")
+  system %(git tag -am "release v#{GEM_VERSION}" v#{GEM_VERSION})
+end

data/bin/rspactor

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 require 'rspactor/runner'
 
-RSpactor::Runner.load
+RSpactor::Runner.start(:coral => ARGV.include?('--coral'))

data/lib/rspactor/inspector.rb

@@ -10,6 +10,9 @@ module RSpactor
 
     def determine_spec_files(file)
       candidates = translate(file)
+      candidates.reject { |candidate| candidate.index('.') }.each do |dir|
+        candidates.reject! { |candidate| candidate.index("#{dir}/") == 0 }
+      end
       spec_files = candidates.select { |candidate| File.exists? candidate }
 
       if spec_files.empty?
@@ -41,6 +44,8 @@ module RSpactor
               candidates << append_spec_file_extension($1)
             elsif file =~ %r:app/helpers/(\w+)_helper.rb:
               candidates << "views/#{$1}"
+            elsif file =~ /_observer.rb$/
+              candidates << candidates.last.sub('_observer', '')
             end
           end
         when %r:^lib/:

data/lib/rspactor/runner.rb

@@ -2,52 +2,95 @@ require 'rspactor'
 
 module RSpactor
   class Runner
-    def self.load
-      dotfile = File.join(ENV['HOME'], '.rspactor')
-      Kernel.load dotfile if File.exists?(dotfile)
-
-      dir = Dir.pwd
-      @inspector  = Inspector.new(dir)
-      @interactor = Interactor.new
-
+    def self.start(options = {})
+      new(Dir.pwd, options).start
+    end
+    
+    attr_reader :dir, :options, :inspector, :interactor
+    
+    def initialize(dir, options = {})
+      @dir = dir
+      @options = options
+      read_git_head
+    end
+    
+    def start
+      load_dotfile
       puts "** RSpactor is now watching at '#{dir}'"
-
-      aborted = initial_spec_run_abort
+      start_interactor
+      start_listener
+    end
+    
+    def start_interactor
+      @interactor = Interactor.new
+      aborted = @interactor.wait_for_enter_key("** Hit <enter> to skip initial spec run", 3)
       @interactor.start_termination_handler
       run_all_specs unless aborted
+    end
+    
+    def start_listener
+      @inspector = Inspector.new(dir)
 
       Listener.new(Inspector::EXTENSIONS) do |files|
-        files_to_spec = []
-        files.each do |file|
-          spec_files = @inspector.determine_spec_files(file)
-          unless spec_files.empty?
-            puts spec_files.join("\n")
-            files_to_spec.concat spec_files
-          end
-        end
-        run_spec_command(files_to_spec)
+        spec_changed_files(files) unless git_head_changed?
       end.run(dir)
     end
-
-    def self.initial_spec_run_abort
-      @interactor.wait_for_enter_key("** Hit <enter> to skip initial spec run", 3)
+    
+    def load_dotfile
+      dotfile = File.join(ENV['HOME'], '.rspactor')
+      if File.exists?(dotfile)
+        begin
+          Kernel.load dotfile
+        rescue => e
+          $stderr.puts "Error while loading #{dotfile}: #{e}"
+        end
+      end
     end
 
-    def self.run_all_specs
+    def run_all_specs
       run_spec_command('spec')
     end
 
-    def self.run_spec_command(paths)
+    def run_spec_command(paths)
       paths = Array(paths)
-      return if paths.empty?
-      run_command [ruby_opts, spec_runner, paths, spec_opts].flatten.join(' ')
+      if paths.empty?
+        @last_run_failed = nil
+      else
+        cmd = [ruby_opts, spec_runner, paths, spec_opts].flatten.join(' ')
+        @last_run_failed = run_command(cmd)
+      end
+    end
+    
+    def last_run_failed?
+      @last_run_failed == false
     end
+    
+    protected
 
-    def self.run_command(cmd)
+    def run_command(cmd)
       system(cmd)
+      $?.success?
     end
+    
+    def spec_changed_files(files)
+      files_to_spec = files.inject([]) do |all, file|
+        all.concat inspector.determine_spec_files(file)
+      end
+      unless files_to_spec.empty?
+        puts files_to_spec.join("\n")
+        
+        previous_run_failed = last_run_failed?
+        run_spec_command(files_to_spec)
+        
+        if options[:retry_failed] and previous_run_failed and not last_run_failed?
+          run_all_specs
+        end
+      end
+    end
+    
+    private
 
-    def self.spec_opts
+    def spec_opts
       if File.exist?('spec/spec.opts')
         opts = File.read('spec/spec.opts').gsub("\n", ' ')
       else
@@ -61,11 +104,11 @@ module RSpactor
       opts
     end
 
-    def self.formatter_opts
+    def formatter_opts
       "-r #{File.dirname(__FILE__)}/../rspec_growler.rb -f RSpecGrowler:STDOUT"
     end
 
-    def self.spec_runner
+    def spec_runner
       if File.exist?("script/spec")
         "script/spec"
       else
@@ -73,10 +116,22 @@ module RSpactor
       end
     end
 
-    def self.ruby_opts
+    def ruby_opts
       other = ENV['RUBYOPT'] ? " #{ENV['RUBYOPT']}" : ''
+      other << ' -rcoral' if options[:coral]
       %(RUBYOPT='-Ilib:spec#{other}')
     end
+    
+    def git_head_changed?
+      old_git_head = @git_head
+      read_git_head
+      @git_head and old_git_head and @git_head != old_git_head
+    end
+    
+    def read_git_head
+      git_head_file = File.join(dir, '.git', 'HEAD')
+      @git_head = File.exists?(git_head_file) && File.read(git_head_file)
+    end
   end
 end
 

data/spec/inspector_spec.rb

@@ -64,6 +64,10 @@ describe RSpactor::Inspector do
       translate('db/schema.rb').should == ['spec/models']
     end
     
+    it "should consider related model when its observer changes" do
+      translate('app/models/user_observer.rb').should == ['spec/models/user_observer_spec.rb', 'spec/models/user_spec.rb']
+    end
+    
     it "should consider all specs when spec_helper changes" do
       translate('spec/spec_helper.rb').should == ['spec']
     end
@@ -78,4 +82,38 @@ describe RSpactor::Inspector do
       translate('config/boot.rb').should == ['spec']
     end
   end
+  
+  describe "#determine_spec_files" do
+    def determine(file)
+      @inspector.determine_spec_files(file)
+    end
+    
+    it "should filter out files that don't exist on the filesystem" do
+      @inspector.should_receive(:translate).with('foo').and_return(%w(valid_spec.rb invalid_spec.rb))
+      File.should_receive(:exists?).with('valid_spec.rb').and_return(true)
+      File.should_receive(:exists?).with('invalid_spec.rb').and_return(false)
+      determine('foo').should == ['valid_spec.rb']
+    end
+    
+    it "should filter out files in subdirectories that are already on the list" do
+      @inspector.should_receive(:translate).with('foo').and_return(%w(
+        spec/foo_spec.rb
+        spec/views/moo/bar_spec.rb
+        spec/views/baa/boo_spec.rb
+        spec/models/baz_spec.rb
+        spec/controllers/moo_spec.rb
+        spec/models
+        spec/controllers
+        spec/views/baa
+      ))
+      File.stub!(:exists?).and_return(true)
+      determine('foo').should == %w(
+        spec/foo_spec.rb
+        spec/views/moo/bar_spec.rb
+        spec/models
+        spec/controllers
+        spec/views/baa
+      )
+    end
+  end
 end

data/spec/runner_spec.rb

@@ -3,16 +3,12 @@ require 'rspactor/runner'
 describe RSpactor::Runner do
   
   described_class.class_eval do
-    def self.run_command(cmd)
+    def run_command(cmd)
       # never shell out in tests
       cmd
     end
   end
   
-  def runner
-    described_class
-  end
-  
   def with_env(name, value)
     old_value = ENV[name]
     ENV[name] = value
@@ -23,81 +19,139 @@ describe RSpactor::Runner do
     end
   end
   
-  describe "setup" do
+  def capture_stderr(io = StringIO.new)
+    @old_stderr, $stderr = $stderr, io
+    begin; yield ensure; restore_stderr; end if block_given?
+  end
+  
+  def restore_stderr
+    $stderr = @old_stderr
+  end
+  
+  def capture_stdout(io = StringIO.new)
+    @old_stdout, $stdout = $stdout, io
+    begin; yield ensure; restore_stdout; end if block_given?
+  end
+  
+  def restore_stdout
+    $stdout = @old_stdout
+  end
+  
+  describe "start" do
     before(:each) do
-      Dir.stub!(:pwd).and_return('/my/path')
-      File.stub!(:exists?).and_return(false)
-      runner.stub!(:puts)
-      RSpactor::Inspector.stub!(:new)
-      RSpactor::Interactor.stub!(:new).and_return(mock('Interactor').as_null_object)
-      RSpactor::Listener.stub!(:new).and_return(mock('Listener').as_null_object)
+      @runner = described_class.new('/my/path')
+      capture_stdout
     end
     
-    def setup
-      runner.load
+    after(:each) do
+      restore_stdout
     end
     
-    it "should initialize Inspector" do
-      RSpactor::Inspector.should_receive(:new).with('/my/path')
-      setup
+    def setup
+      @runner.start
     end
+    
+    context "Interactor" do
+      before(:each) do
+        @runner.stub!(:load_dotfile)
+        @runner.stub!(:start_listener)
+        @interactor = mock('Interactor')
+        @interactor.should_receive(:start_termination_handler)
+        RSpactor::Interactor.should_receive(:new).and_return(@interactor)
+      end
+      
+      it "should start Interactor" do
+        @interactor.should_receive(:wait_for_enter_key).with(instance_of(String), 3)
+        setup
+      end
   
-    it "should start Interactor" do
-      interactor = mock('Interactor')
-      interactor.should_receive(:wait_for_enter_key).with(instance_of(String), 3)
-      interactor.should_receive(:start_termination_handler)
-      RSpactor::Interactor.should_receive(:new).and_return(interactor)
-      setup
-    end
+      it "should run all specs if Interactor isn't interrupted" do
+        @interactor.should_receive(:wait_for_enter_key).and_return(nil)
+        @runner.should_receive(:run_spec_command).with('spec')
+        setup
+      end
   
-    it "should run all specs if Interactor isn't interrupted" do
-      interactor = mock('Interactor', :start_termination_handler => nil)
-      interactor.should_receive(:wait_for_enter_key).and_return(nil)
-      RSpactor::Interactor.should_receive(:new).and_return(interactor)
-      runner.should_receive(:run_spec_command).with('spec')
-      setup
+      it "should skip running all specs if Interactor is interrupted" do
+        @interactor.should_receive(:wait_for_enter_key).and_return(true)
+        @runner.should_not_receive(:run_spec_command)
+        setup
+      end
     end
-  
-    it "should skip running all specs if Interactor is interrupted" do
-      interactor = mock('Interactor', :start_termination_handler => nil)
-      interactor.should_receive(:wait_for_enter_key).and_return(true)
-      RSpactor::Interactor.should_receive(:new).and_return(interactor)
-      runner.should_not_receive(:run_spec_command)
+    
+    it "should initialize Inspector" do
+      @runner.stub!(:load_dotfile)
+      @runner.stub!(:start_interactor)
+      RSpactor::Inspector.should_receive(:new).with('/my/path')
+      RSpactor::Listener.stub!(:new).and_return(mock('Listener').as_null_object)
       setup
     end
-  
-    it "should run Listener" do
-      listener = mock('Listener')
-      listener.should_receive(:run).with('/my/path')
-      RSpactor::Listener.should_receive(:new).with(instance_of(Array)).and_return(listener)
-      setup
+    
+    context "Listener" do
+      before(:each) do
+        @runner.stub!(:load_dotfile)
+        @runner.stub!(:start_interactor)
+        @inspector = mock("Inspector")
+        RSpactor::Inspector.stub!(:new).and_return(@inspector)
+        @listener = mock('Listener')
+      end
+      
+      it "should run Listener" do
+        @listener.should_receive(:run).with('/my/path')
+        RSpactor::Listener.should_receive(:new).with(instance_of(Array)).and_return(@listener)
+        setup
+      end
     end
   
     it "should output 'watching' message on start" do
-      runner.should_receive(:puts).with("** RSpactor is now watching at '/my/path'")
+      @runner.stub!(:load_dotfile)
+      @runner.stub!(:start_interactor)
+      @runner.stub!(:start_listener)
       setup
+      $stdout.string.chomp.should == "** RSpactor is now watching at '/my/path'"
     end
     
-    it "should load dotfile if found" do
-      with_env('HOME', '/home/moo') do
-        File.should_receive(:exists?).with('/home/moo/.rspactor').and_return(true)
-        Kernel.should_receive(:load).with('/home/moo/.rspactor')
-        setup
+    context "dotfile" do
+      before(:each) do
+        @runner.stub!(:start_interactor)
+        @runner.stub!(:start_listener)
+      end
+      
+      it "should load dotfile if found" do
+        with_env('HOME', '/home/moo') do
+          File.should_receive(:exists?).with('/home/moo/.rspactor').and_return(true)
+          Kernel.should_receive(:load).with('/home/moo/.rspactor')
+          setup
+        end
+      end
+    
+      it "should continue even if the dotfile raised errors" do
+        with_env('HOME', '/home/moo') do
+          File.should_receive(:exists?).and_return(true)
+          Kernel.should_receive(:load).with('/home/moo/.rspactor').and_raise(ArgumentError)
+          capture_stderr do
+            lambda { setup }.should_not raise_error
+            $stderr.string.split("\n").should include('Error while loading /home/moo/.rspactor: ArgumentError')
+          end
+        end
       end
     end
   end
   
   describe "#run_spec_command" do
+    before(:each) do
+      @runner = described_class.new('/my/path')
+    end
+    
     def with_rubyopt(string, &block)
       with_env('RUBYOPT', string, &block)
     end
     
     def run(paths)
-      runner.run_spec_command(paths)
+      @runner.run_spec_command(paths)
     end
     
     it "should exit if the paths argument is empty" do
-      runner.should_not_receive(:run_command)
+      @runner.should_not_receive(:run_command)
       run([])
     end
     
@@ -130,14 +184,61 @@ describe RSpactor::Runner do
     end
     
     it "should not include 'progress' formatter if there already are 2 or more formatters" do
-      runner.should_receive(:formatter_opts).and_return('-f foo --format bar')
+      @runner.should_receive(:formatter_opts).and_return('-f foo --format bar')
       run('foo').should_not include('-f progress')
     end
+    
+    it "should save status of last run" do
+      @runner.should_receive(:run_command).twice.and_return(true, false)
+      run('foo')
+      @runner.last_run_failed?.should be_false
+      run('bar')
+      @runner.last_run_failed?.should be_true
+      run([])
+      @runner.last_run_failed?.should be_false
+    end
+  end
+  
+  describe "#spec_changed_files" do
+    before(:each) do
+      @runner = described_class.new('.')
+      @runner.stub!(:inspector).and_return(mock("Inspector"))
+    end
+    
+    def set_inspector_expectation(file, ret)
+      @runner.inspector.should_receive(:determine_spec_files).with(file).and_return(ret)
+    end
+    
+    it "should find and run spec files" do
+      set_inspector_expectation('moo.rb', ['spec/moo_spec.rb'])
+      set_inspector_expectation('views/baz.haml', [])
+      set_inspector_expectation('config/bar.yml', ['spec/bar_spec.rb', 'spec/bar_stuff_spec.rb'])
+      
+      expected = %w(spec/moo_spec.rb spec/bar_spec.rb spec/bar_stuff_spec.rb)
+      @runner.should_receive(:run_spec_command).with(expected)
+      
+      capture_stdout do
+        @runner.send(:spec_changed_files, %w(moo.rb views/baz.haml config/bar.yml))
+        $stdout.string.split("\n").should == expected
+      end
+    end
+    
+    it "should run the full suite after a run succeded when the previous one failed" do
+      @runner.inspector.stub!(:determine_spec_files).and_return(['spec/foo_spec.rb'], ['spec/bar_spec.rb'])
+      @runner.stub!(:options).and_return({ :retry_failed => true })
+      
+      capture_stdout do
+        @runner.stub!(:run_spec_command)
+        @runner.should_receive(:last_run_failed?).and_return(true, false)
+        @runner.should_receive(:run_all_specs)
+        @runner.send(:spec_changed_files, %w(moo.rb))
+      end
+    end
   end
   
   it "should have Runner in global namespace for backwards compatibility" do
     defined?(::Runner).should be_true
-    ::Runner.should == runner
+    ::Runner.should == described_class
   end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mislav-rspactor
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors: 
 - "Mislav Marohni\xC4\x87"
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-17 00:00:00 -07:00
+date: 2009-03-27 00:00:00 -07:00
 default_executable: rspactor
 dependencies: []