lacomartincik-rspactor 0.3.3.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Mislav Marohnić
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,57 @@
+task :default => :spec
+
+desc "starts RSpactor"
+task :spec do
+  system "ruby -Ilib bin/rspactor"
+end
+
+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
+end
+
+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 :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

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require 'rspactor/runner'
+
+RSpactor::Runner.start({
+  :coral => ARGV.delete('--coral'),
+  :run_in => ARGV.last
+})

data/bin/rspactor-system

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+require 'rspactor'
+Growl = RSpactor::Growl
+
+root = ENV['HOME']
+$mappings = []
+$libs = []
+
+def map(regex, &block)
+  $mappings << [regex, block]
+end
+
+def libs
+  $libs
+end
+
+def title
+  $title
+end
+
+listener = RSpactor::Listener.new do |changed_files|
+  changed_files.reject! do |file|
+    file.index(root + "/Library/") == 0
+  end
+  
+  if changed_files.size == 1
+    changed_file = changed_files.first
+    dir = changed_file
+    hook = nil
+    
+    until hook or (dir = File.dirname(dir)) == root
+      candidate = dir + "/.rspactor"
+      hook = candidate if File.exists?(candidate)
+    end 
+    
+    if hook
+      targets = []
+      $title = "Test results"
+      $mappings.clear
+      $libs.replace ['lib']
+      load hook
+      
+      unless $mappings.empty?
+        relative_path = changed_file.sub(dir + '/', '')
+        
+        for regex, block in $mappings
+          if match = relative_path.match(regex)
+            targets.concat Array(block.call(relative_path, match))
+            break
+          end
+        end
+        
+        existing_targets = targets.select { |file| File.exist?(File.join(dir, file)) }
+      else
+        inspector = RSpactor::Inspector.new(dir)
+        existing_targets = inspector.determine_spec_files(changed_file)
+      end
+
+      unless existing_targets.empty?
+        case existing_targets.first
+        when %r{^test/}
+          $libs << 'test'
+        when %r{^spec/}
+          $libs << 'spec'
+        end
+        
+        Dir.chdir(dir) do
+          unless 'spec' == $libs.last
+            command = "ruby -I#{$libs.join(':')} -e 'ARGV.each{|f| load f}' "
+          else
+            command = "RUBYOPT='-I#{$libs.join(':')}' spec --color "
+          end
+          command << existing_targets.join(' ')
+          # puts command
+          system command
+        end
+
+        if $?.success?
+          Growl::notify $title, "You rock!", Growl::image_path('success')
+        else
+          Growl::notify $title, "YOU LOSE", Growl::image_path('failed')
+        end
+      else
+        $stderr.puts "-- don't know how to run #{changed_file}"
+      end
+    end
+  end
+end
+
+listener.run(root)

data/lib/rspactor/growl.rb

@@ -0,0 +1,14 @@
+module RSpactor
+  module Growl
+    extend self
+    
+    def notify(title, msg, img, pri = 0)
+      system("growlnotify -w -n rspactor --image #{img} -p #{pri} -m #{msg.inspect} #{title} &") 
+    end
+    
+    # failed | pending | success
+    def image_path(icon)
+      File.expand_path File.dirname(__FILE__) + "/../../images/#{icon}.png"
+    end
+  end
+end

data/lib/rspactor/interactor.rb

@@ -0,0 +1,63 @@
+require 'timeout'
+
+module RSpactor
+  class Interactor
+    def initialize
+      ticker
+    end
+
+    def wait_for_enter_key(msg, seconds_to_wait)
+      begin
+        Timeout::timeout(seconds_to_wait) do
+          ticker(:start => true, :msg => msg)
+          $stdin.gets
+          return true
+        end
+      rescue Timeout::Error
+        false
+      ensure
+        ticker(:stop => true)
+      end
+    end
+
+    def start_termination_handler
+      @main_thread = Thread.current
+      Thread.new do
+        loop do
+          sleep 0.5
+          if $stdin.gets
+            if wait_for_enter_key("** Running all specs.. Hit <enter> again to exit RSpactor", 3)
+              @main_thread.exit
+              exit
+            end
+            Runner.run_all_specs
+          end
+        end
+      end
+    end
+
+    private
+
+    def ticker(opts = {})
+      if opts[:stop]
+        $stdout.puts "\n"
+        @pointer_running = false
+      elsif opts[:start]
+        @pointer_running = true
+        write(opts[:msg]) if opts[:msg]
+      else
+        Thread.new do
+          loop do
+            write('.') if @pointer_running == true
+            sleep 1.0
+          end
+        end
+      end
+    end
+
+    def write(msg)
+      $stdout.print(msg)
+      $stdout.flush
+    end
+  end
+end

data/lib/rspactor/listener.rb

@@ -0,0 +1,86 @@
+require 'osx/foundation'
+OSX.require_framework '/System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework'
+
+module RSpactor
+  # based on http://rails.aizatto.com/2007/11/28/taming-the-autotest-beast-with-fsevents/
+  class Listener
+    attr_reader :last_check, :callback, :valid_extensions
+
+    def initialize(valid_extensions = nil)
+      @valid_extensions = valid_extensions
+      timestamp_checked
+
+      @callback = lambda do |stream, ctx, num_events, paths, marks, event_ids|
+        changed_files = extract_changed_files_from_paths(split_paths(paths, num_events))
+        timestamp_checked
+        yield changed_files unless changed_files.empty?
+      end
+    end
+
+    def run(directories)
+      dirs = Array(directories)
+      stream = OSX::FSEventStreamCreate(OSX::KCFAllocatorDefault, callback, nil, dirs, OSX::KFSEventStreamEventIdSinceNow, 0.5, 0)
+      unless stream
+        $stderr.puts "Failed to create stream"
+        exit(1)
+      end
+
+      OSX::FSEventStreamScheduleWithRunLoop(stream, OSX::CFRunLoopGetCurrent(), OSX::KCFRunLoopDefaultMode)
+      unless OSX::FSEventStreamStart(stream)
+        $stderr.puts "Failed to start stream"
+        exit(1)
+      end
+
+      begin
+        OSX::CFRunLoopRun()
+      rescue Interrupt
+        OSX::FSEventStreamStop(stream)
+        OSX::FSEventStreamInvalidate(stream)
+        OSX::FSEventStreamRelease(stream)
+      end
+    end
+
+    def timestamp_checked
+      @last_check = Time.now
+    end
+
+    def split_paths(paths, num_events)
+      paths.regard_as('*')
+      rpaths = []
+      num_events.times { |i| rpaths << paths[i] }
+      rpaths
+    end
+
+    def extract_changed_files_from_paths(paths)
+      changed_files = []
+      paths.each do |path|
+        next if ignore_path?(path)
+        Dir.glob(path + "*").each do |file|
+          next if ignore_file?(file)
+          changed_files << file if file_changed?(file)
+        end
+      end
+      changed_files
+    end
+
+    def file_changed?(file)
+      File.stat(file).mtime > last_check
+    end
+
+    def ignore_path?(path)
+      path =~ /(?:^|\/)\.(git|svn)/
+    end
+
+    def ignore_file?(file)
+      File.basename(file).index('.') == 0 or not valid_extension?(file)
+    end
+
+    def file_extension(file)
+      file =~ /\.(\w+)$/ and $1
+    end
+
+    def valid_extension?(file)
+      valid_extensions.nil? or valid_extensions.include?(file_extension(file))
+    end
+  end
+end

data/lib/rspactor/rspec_inspector.rb

@@ -0,0 +1,89 @@
+module RSpactor
+  # Maps the changed filenames to list of specs to run in the next go.
+  # Assumes Rails-like directory structure
+  class RSpecInspector
+    EXTENSIONS = %w(rb erb builder haml rhtml rxml yml conf opts)
+
+    def initialize(dir)
+      @root = dir
+    end
+
+    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?
+        $stderr.puts "doesn't exist: #{candidates.inspect}"
+      end
+      spec_files
+    end
+
+    # mappings for Rails are inspired by autotest mappings in rspec-rails
+    def translate(file)
+      file = file.sub(%r:^#{Regexp.escape(@root)}/:, '')
+      candidates = []
+
+      if spec_file?(file)
+        candidates << file
+      else
+        spec_file = append_spec_file_extension(file)
+
+        case file
+        when %r:^app/:
+          if file =~ %r:^app/controllers/application(_controller)?.rb$:
+            candidates << 'controllers'
+          elsif file == 'app/helpers/application_helper.rb'
+            candidates << 'helpers' << 'views'
+          else
+            candidates << spec_file.sub('app/', '')
+
+            if file =~ %r:^app/(views/.+\.[a-z]+)\.[a-z]+$:
+              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/:
+          candidates << spec_file
+          # lib/foo/bar_spec.rb -> lib/bar_spec.rb
+          candidates << candidates.last.sub($&, '')
+          # lib/bar_spec.rb -> bar_spec.rb
+          candidates << candidates.last.sub(%r:\w+/:, '') if candidates.last.index('/')
+        when 'config/routes.rb'
+          candidates << 'controllers' << 'helpers' << 'views'
+        when 'config/database.yml', 'db/schema.rb'
+          candidates << 'models'
+        when %r:^(spec/(spec_helper|shared/.*)|config/(boot|environment(s/test)?))\.rb$:, 'spec/spec.opts'
+          candidates << 'spec'
+        else
+          candidates << spec_file
+        end
+      end
+
+      candidates.map do |candidate|
+        if candidate.index('spec') == 0
+          File.join(@root, candidate)
+        else
+          File.join(@root, 'spec', candidate)
+        end
+      end
+    end
+
+    def append_spec_file_extension(file)
+      if File.extname(file) == ".rb"
+        file.sub(/.rb$/, "_spec.rb")
+      else
+        file + "_spec.rb"
+      end
+    end
+
+    def spec_file?(file)
+      file =~ /^spec\/.+_spec.rb$/
+    end
+  end
+end

data/lib/rspactor/runner.rb

@@ -0,0 +1,176 @@
+require 'rspactor'
+
+module RSpactor
+  class Runner
+    def self.start(options = {})
+      run_in = options.delete(:run_in) || Dir.pwd
+      new(run_in, options).start
+    end
+    
+    attr_reader :dir, :options, :inspector, :interactor, :rspec
+    
+    def initialize(dir, options = {})
+      @dir = dir
+      @options = options
+      @rspec = File.exists?(File.join(dir, 'spec'))
+      read_git_head
+    end
+    
+    def start
+      load_dotfile
+      puts "** RSpactor is now watching at '#{dir}'"
+      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_tests unless aborted
+    end
+    
+    def start_listener
+      @inspector_class = rspec? ? RSpecInspector : TestInspector
+      @inspector = @inspector_class.new(dir)
+
+      Listener.new(@inspector_class::EXTENSIONS) do |files|
+        test_changed_files(files) unless git_head_changed?
+      end.run(dir)
+    end
+    
+    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 run_all_tests
+      if rspec?
+        run_spec_command(File.join(dir, 'spec'))
+      else
+        patterns = ["test/unit/**/*_test.rb", "test/lib/**/*_test.rb", 
+          "test/functional/**/*_test.rb", "test/integration/**/*_test.rb"]
+        
+        file_list = []
+        patterns.each do |pattern|
+          file_list = Dir[pattern]
+        end
+        run_test_command(file_list)
+      end
+    end
+
+    def run_spec_command(paths)
+      paths = Array(paths)
+      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 run_test_command(paths)
+      paths = Array(paths)
+      if paths.empty?
+        @last_run_failed = nil
+      else
+        cmd = [ruby_opts, test_runner, paths].flatten.join(' ')
+        @last_run_failed = run_command(cmd)
+      end
+    end
+    
+    def last_run_failed?
+      @last_run_failed == false
+    end
+    
+    protected
+
+    def run_command(cmd)
+      system(cmd)
+      $?.success?
+    end
+    
+    def test_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_tests
+        end
+      end
+    end
+    
+    def rspec?
+      rspec ? true : false
+    end
+    
+    private
+
+    def spec_opts
+      if File.exist?('spec/spec.opts')
+        opts = File.read('spec/spec.opts').gsub("\n", ' ')
+      else
+        opts = "--color"
+      end
+
+      opts << ' ' << formatter_opts
+      # only add the "progress" formatter unless no other (besides growl) is specified
+      opts << ' -f progress' unless opts.scan(/\s(?:-f|--format)\b/).length > 1
+
+      opts
+    end
+
+    def formatter_opts
+      "-r #{File.dirname(__FILE__)}/../rspec_growler.rb -f RSpecGrowler:STDOUT"
+    end
+
+    def spec_runner
+      if File.exist?("script/spec")
+        "script/spec"
+      else
+        "spec"
+      end
+    end
+    
+    def test_runner
+      'ruby'
+    end
+
+    def ruby_opts
+      other = ENV['RUBYOPT'] ? " #{ENV['RUBYOPT']}" : ''
+      other << ' -rcoral' if options[:coral]
+      if rspec?
+        %(RUBYOPT='-Ilib:spec#{other}')
+      else
+        %(RUBYOPT='-Ilib:test#{other}')
+      end
+    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
+
+# backward compatibility
+Runner = RSpactor::Runner

data/lib/rspactor/test_inspector.rb

@@ -0,0 +1,89 @@
+module RSpactor
+  # Maps the changed filenames to list of specs to run in the next go.
+  # Assumes Rails-like directory structure
+  class TestInspector
+    EXTENSIONS = %w(rb erb builder haml rhtml rxml yml conf opts)
+
+    def initialize(dir)
+      @root = dir
+    end
+
+    def determine_test_files(file)
+      candidates = translate(file)
+      candidates.reject { |candidate| candidate.index('.') }.each do |dir|
+        candidates.reject! { |candidate| candidate.index("#{dir}/") == 0 }
+      end
+      test_files = candidates.select { |candidate| File.exists? candidate }
+
+      if test_files.empty?
+        $stderr.puts "doesn't exist: #{candidates.inspect}"
+      end
+      test_files
+    end
+
+    # mappings for Rails are inspired by autotest mappings in rspec-rails
+    def translate(file)
+      file = file.sub(%r:^#{Regexp.escape(@root)}/:, '')
+      candidates = []
+
+      if test_file?(file)
+        candidates << file
+      else
+        test_file = append_test_file_extension(file)
+
+        case file
+        when %r:^app/:
+          if file =~ %r:^app/controllers/application(_controller)?.rb$:
+            candidates << 'controllers'
+          elsif file == 'app/helpers/application_helper.rb'
+            candidates << 'helpers' << 'views'
+          else
+            candidates << test_file.sub('app/', '')
+
+            if file =~ %r:^app/(views/.+\.[a-z]+)\.[a-z]+$:
+              candidates << append_test_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/:
+          candidates << test_file
+          # lib/foo/bar_test.rb -> lib/bar_test.rb
+          candidates << candidates.last.sub($&, '')
+          # lib/bar_test.rb -> bar_test.rb
+          candidates << candidates.last.sub(%r:\w+/:, '') if candidates.last.index('/')
+        when 'config/routes.rb'
+          candidates << 'controllers' << 'helpers' << 'views'
+        when 'config/database.yml', 'db/schema.rb'
+          candidates << 'models'
+        when %r:^(spec/(spec_helper|shared/.*)|config/(boot|environment(s/test)?))\.rb$:
+          candidates << 'test'
+        else
+          candidates << test_file
+        end
+      end
+
+      candidates.map do |candidate|
+        if candidate.index('test') == 0
+          File.join(@root, candidate)
+        else
+          File.join(@root, 'test', candidate)
+        end
+      end
+    end
+
+    def append_test_file_extension(file)
+      if File.extname(file) == ".rb"
+        file.sub(/.rb$/, "_test.rb")
+      else
+        file + "_test.rb"
+      end
+    end
+
+    def test_file?(file)
+      file =~ /^test\/.+_test.rb$/
+    end
+  end
+end

data/lib/rspactor.rb

@@ -0,0 +1,8 @@
+module RSpactor
+  autoload :Interactor, 'rspactor/interactor'
+  autoload :Listener, 'rspactor/listener'
+  autoload :RSpecInspector, 'rspactor/rspec_inspector'
+  autoload :TestInspector, 'rspactor/test_inspector'
+  autoload :Runner, 'rspactor/runner'
+  autoload :Growl, 'rspactor/growl'
+end

data/lib/rspec_growler.rb

@@ -0,0 +1,26 @@
+require 'spec/runner/formatter/base_formatter'
+require File.dirname(__FILE__) + '/rspactor/growl'
+
+class RSpecGrowler < Spec::Runner::Formatter::BaseFormatter
+  include RSpactor::Growl
+  
+  def dump_summary(duration, total, failures, pending)
+    icon = if failures > 0
+      'failed'
+    elsif pending > 0
+      'pending'
+    else
+      'success'
+    end
+    
+    image_path = File.dirname(__FILE__) + "/../images/#{icon}.png"
+    message = "#{total} examples, #{failures} failures"
+    
+    if pending > 0
+      message << " (#{pending} pending)"
+    end
+    
+    notify "Test Results", message, image_path(icon)
+  end
+end
+

data/spec/listener_spec.rb

@@ -0,0 +1,39 @@
+require 'rspactor/listener'
+
+describe RSpactor::Listener do
+  before(:all) do
+    @listener = described_class.new(%w(rb erb haml))
+  end
+  
+  it "should be timestamped" do
+    @listener.last_check.should be_instance_of(Time)
+  end
+  
+  it "should not ignore regular directories" do
+    @listener.ignore_path?('/project/foo/bar').should_not be
+  end
+  
+  it "should ignore .git directories" do
+    @listener.ignore_path?('/project/.git/index').should be
+  end
+  
+  it "should ignore dotfiles" do
+    @listener.ignore_file?('/project/.foo').should be
+  end
+  
+  it "should not ignore files in directories which start with a dot" do
+    @listener.ignore_file?('/project/.foo/bar.rb').should be_false
+  end
+  
+  it "should not ignore files without extension" do
+    @listener.ignore_file?('/project/foo.rb').should be_false
+  end
+  
+  it "should ignore files without extension" do
+    @listener.ignore_file?('/project/foo').should be
+  end
+  
+  it "should ignore files with extensions that don't match those specified" do
+    @listener.ignore_file?('/project/foo.bar').should be
+  end
+end

data/spec/rspec_inspector_spec.rb

@@ -0,0 +1,119 @@
+require 'rspactor/rspec_inspector'
+
+describe RSpactor::RSpecInspector do
+  before(:all) do
+    @inspector = described_class.new('/project')
+  end
+  
+  def translate(file)
+    @inspector.translate(file)
+  end
+  
+  describe "#translate" do
+    it "should consider all controllers when application_controller changes" do
+      translate('/project/app/controllers/application_controller.rb').should == ['/project/spec/controllers']
+      translate('/project/app/controllers/application.rb').should == ['/project/spec/controllers']
+    end
+    
+    it "should translate files under 'app/' directory" do
+      translate('/project/app/controllers/foo_controller.rb').should ==
+        ['/project/spec/controllers/foo_controller_spec.rb']
+    end
+    
+    it "should translate templates" do
+      translate('/project/app/views/foo/bar.erb').should == ['/project/spec/views/foo/bar.erb_spec.rb']
+      translate('/project/app/views/foo/bar.html.haml').should ==
+        ['/project/spec/views/foo/bar.html.haml_spec.rb', '/project/spec/views/foo/bar.html_spec.rb']
+    end
+    
+    it "should consider all views when application_helper changes" do
+      translate('/project/app/helpers/application_helper.rb').should == ['/project/spec/helpers', '/project/spec/views']
+    end
+    
+    it "should consider related templates when a helper changes" do
+      translate('/project/app/helpers/foo_helper.rb').should ==
+        ['/project/spec/helpers/foo_helper_spec.rb', '/project/spec/views/foo']
+    end
+    
+    it "should translate files under deep 'lib/' directory" do
+      translate('/project/lib/awesum/rox.rb').should ==
+        ['/project/spec/lib/awesum/rox_spec.rb', '/project/spec/awesum/rox_spec.rb', '/project/spec/rox_spec.rb']
+    end
+    
+    it "should translate files under shallow 'lib/' directory" do
+      translate('lib/runner.rb').should == ['/project/spec/lib/runner_spec.rb', '/project/spec/runner_spec.rb']
+    end
+    
+    it "should handle relative paths" do
+      translate('foo.rb').should == ['/project/spec/foo_spec.rb']
+    end
+    
+    it "should handle files without extension" do
+      translate('foo').should == ['/project/spec/foo_spec.rb']
+    end
+    
+    it "should consider all controllers, helpers and views when routes.rb changes" do
+      translate('config/routes.rb').should == ['/project/spec/controllers', '/project/spec/helpers', '/project/spec/views']
+    end
+    
+    it "should consider all models when config/database.yml changes" do
+      translate('config/database.yml').should == ['/project/spec/models']
+    end
+    
+    it "should consider all models when db/schema.rb changes" do
+      translate('db/schema.rb').should == ['/project/spec/models']
+    end
+    
+    it "should consider related model when its observer changes" do
+      translate('app/models/user_observer.rb').should == ['/project/spec/models/user_observer_spec.rb', '/project/spec/models/user_spec.rb']
+    end
+    
+    it "should consider all specs when spec_helper changes" do
+      translate('spec/spec_helper.rb').should == ['/project/spec']
+    end
+    
+    it "should consider all specs when code under spec/shared/ changes" do
+      translate('spec/shared/foo.rb').should == ['/project/spec']
+    end
+    
+    it "should consider all specs when app configuration changes" do
+      translate('config/environment.rb').should == ['/project/spec']
+      translate('config/environments/test.rb').should == ['/project/spec']
+      translate('config/boot.rb').should == ['/project/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

@@ -0,0 +1,258 @@
+require 'rspactor/runner'
+
+describe RSpactor::Runner do
+  
+  described_class.class_eval do
+    def run_command(cmd)
+      # never shell out in tests
+      cmd
+    end
+  end
+  
+  def with_env(name, value)
+    old_value = ENV[name]
+    ENV[name] = value
+    begin
+      yield
+    ensure
+      ENV[name] = old_value
+    end
+  end
+  
+  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
+  
+  it 'should use the current directory to run in' do
+    mock_instance = mock('RunnerInstance')
+    mock_instance.stub!(:start)
+    RSpactor::Runner.should_receive(:new).with(Dir.pwd, {}).and_return(mock_instance)
+    RSpactor::Runner.start
+  end
+  
+  it 'should take an optional directory to run in' do
+    mock_instance = mock('RunnerInstance')
+    mock_instance.stub!(:start)
+    RSpactor::Runner.should_receive(:new).with('/tmp/mu', {}).and_return(mock_instance)
+    RSpactor::Runner.start(:run_in => '/tmp/mu')
+  end
+  
+  describe "start" do
+    before(:each) do
+      @runner = described_class.new('/my/path')
+      capture_stdout
+    end
+    
+    after(:each) do
+      restore_stdout
+    end
+    
+    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 run all specs if Interactor isn't interrupted" do
+        @interactor.should_receive(:wait_for_enter_key).and_return(nil)
+        @runner.should_receive(:run_test_command).with([])
+        setup
+      end
+  
+      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 initialize RSpecInspector" do
+      @runner.stub!(:load_dotfile)
+      @runner.stub!(:start_interactor)
+      RSpactor::TestInspector.should_receive(:new).with('/my/path')
+      RSpactor::Listener.stub!(:new).and_return(mock('Listener').as_null_object)
+      setup
+    end
+    
+    context "Listener" do
+      before(:each) do
+        @runner.stub!(:load_dotfile)
+        @runner.stub!(:start_interactor)
+        @inspector = mock("Inspector")
+        RSpactor::TestInspector.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.stub!(:load_dotfile)
+      @runner.stub!(:start_interactor)
+      @runner.stub!(:start_listener)
+      setup
+      $stdout.string.chomp.should == "** RSpactor is now watching at '/my/path'"
+    end
+    
+    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)
+    end
+    
+    it "should exit if the paths argument is empty" do
+      @runner.should_not_receive(:run_command)
+      run([])
+    end
+    
+    it "should specify runner spec runner with joined paths" do
+      run(%w(foo bar)).should include(' spec foo bar ')
+    end
+    
+    it "should specify default options: --color" do
+      run('foo').should include(' --color')
+    end
+    
+    it "should setup RUBYOPT environment variable" do
+      with_rubyopt(nil) do
+        run('foo').should include("RUBYOPT='-Ilib:test' ")
+      end
+    end
+    
+    it "should concat existing RUBYOPTs" do
+      with_rubyopt('-rubygems -w') do
+        run('foo').should include("RUBYOPT='-Ilib:test -rubygems -w' ")
+      end
+    end
+    
+    it "should include growl formatter" do
+      run('foo').should include(' -f RSpecGrowler:STDOUT')
+    end
+    
+    it "should include 'progress' formatter" do
+      run('foo').should include(' -f progress')
+    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')
+      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 "#test_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(:test_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_tests)
+        @runner.send(:test_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 == described_class
+  end
+  
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: lacomartincik-rspactor
+version: !ruby/object:Gem::Version 
+  version: 0.3.3.1
+platform: ruby
+authors: 
+- "Mislav Marohni\xC4\x87"
+- Andreas Wolff
+- Pelle Braendgaard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-11 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: mislav.marohnic@gmail.com
+executables: 
+- rspactor
+- rspactor-system
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- bin/rspactor
+- bin/rspactor-system
+- lib/rspactor
+- lib/rspactor/growl.rb
+- lib/rspactor/interactor.rb
+- lib/rspactor/listener.rb
+- lib/rspactor/rspec_inspector.rb
+- lib/rspactor/runner.rb
+- lib/rspactor/test_inspector.rb
+- lib/rspactor.rb
+- lib/rspec_growler.rb
+- images/failed.png
+- images/pending.png
+- images/success.png
+- spec/listener_spec.rb
+- spec/rspec_inspector_spec.rb
+- spec/runner_spec.rb
+- LICENSE
+has_rdoc: false
+homepage: http://github.com/mislav/rspactor
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: RSpactor is a command line tool to automatically run your changed specs (much like autotest).
+test_files: []
+