rspactor 0.2.0 → 0.5.4

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Andreas Wolff
+
+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,58 @@
+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 & cucumber features (much like autotest)."
+    gem.description = "read summary!"
+    gem.email = "guillaumegentil@gmail.com"
+    gem.homepage = "http://github.com/guillaumegentil/rspactor"
+    gem.authors = ["Mislav Marohnić", "Andreas Wolff", "Pelle Braendgaard", "Thibaud Guillaume-Gentil"]
+    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

@@ -1,8 +1,11 @@
 #!/usr/bin/env ruby
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib/rspactor'))
 
-require File.join(File.dirname(__FILE__), '..', 'lib', 'interactor')
-require File.join(File.dirname(__FILE__), '..', 'lib', 'listener')
-require File.join(File.dirname(__FILE__), '..', 'lib', 'inspector')
-require File.join(File.dirname(__FILE__), '..', 'lib', 'runner')
-
-Runner.load
+RSpactor::Runner.start({
+  :coral => ARGV.delete('--coral'),
+  :celerity => ARGV.delete('--celerity'),
+  :spork => ARGV.delete('--drb'),
+  :view => ARGV.delete('--view'), # by default, rspactor didn't catch specs view
+  :clear => ARGV.delete('--clear'),
+  :run_in => ARGV.last
+})

data/lib/cucumber_growler.rb

@@ -0,0 +1,61 @@
+require 'cucumber'
+require 'cucumber/formatter/console'
+require File.dirname(__FILE__) + '/rspactor/growl'
+
+module CucumberGrowler
+  include RSpactor::Growl
+  
+  def self.included(base)
+    base.class_eval do
+      alias original_print_stats print_stats
+      include InstanceMethods
+      
+      def print_stats(features)
+        title, icon, messages = '', '', []
+        [:failed, :skipped, :undefined, :pending, :passed].reverse.each do |status|
+          if step_mother.steps(status).any?
+            icon = icon_for(status)
+            # title = title_for(status)
+            messages << dump_count(step_mother.steps(status).length, "step", status.to_s)
+          end
+        end
+        
+        notify "Cucumber Results", messages.reverse.join(", "), icon
+        original_print_stats(features)
+      end
+    end
+  end
+  
+  module InstanceMethods
+    def icon_for(status)
+      case status
+      when :passed
+        'success'
+      when :pending, :undefined, :skipped
+        'pending'
+      when :failed
+        'failed'
+      end
+    end
+    
+    def title_for(status)
+      case status
+      when :passed
+        'Features passed!'
+      when :pending
+        'Some steps are pending...'
+      when :undefined
+        'Some undefined steps...'
+      when :skipped
+        'Some steps skipped...'
+      when :failed
+        'Failures occurred!'
+      end
+    end
+  end
+  
+end
+
+module Cucumber::Formatter::Console
+  include CucumberGrowler
+end

data/lib/rspactor/celerity.rb

@@ -0,0 +1,29 @@
+require 'rspactor'
+
+module RSpactor
+  class Celerity
+    
+    def self.start(dir)
+      pid_path = "#{dir}/tmp/pids/mongrel_celerity.pid"
+      if File.exist?(pid_path)
+        system("kill $(head #{pid_path}) >/dev/null 2>&1")
+        system("rm #{pid_path} >/dev/null 2>&1")
+      end
+      # kill other mongrels
+      system("kill $(ps aux | grep 'mongrel_rails' | grep -v grep | awk '//{print $2;}') >/dev/null 2>&1")
+      system("rake celerity_server:start >/dev/null 2>&1 &")
+      Interactor.ticker_msg "** Starting celerity server"
+    end
+    
+    def self.restart
+      system("rake celerity_server:stop >/dev/null 2>&1 && rake celerity_server:start >/dev/null 2>&1 &")
+      Interactor.ticker_msg "** Restarting celerity server"
+    end
+    
+    def self.kill_jruby
+      system("kill $(ps aux | grep jruby | grep -v grep | awk '//{print $2;}') >/dev/null 2>&1")
+      true
+    end
+    
+  end
+end

data/lib/rspactor/growl.rb

@@ -0,0 +1,14 @@
+module RSpactor
+  module Growl
+    extend self
+    
+    def notify(title, msg, icon, pri = 0)
+      system("growlnotify -w -n rspactor --image #{image_path(icon)} -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/inspector.rb

@@ -0,0 +1,110 @@
+require 'rspactor'
+
+module RSpactor
+  # Maps the changed filenames to list of specs to run in the next go.
+  # Assumes Rails-like directory structure
+  class Inspector
+    EXTENSIONS = %w(rb erb builder haml rhtml rxml yml conf opts feature)
+    
+    attr_reader :runner, :root
+    
+    def initialize(runner)
+      @runner = runner
+      @root = runner.dir
+    end
+    
+    def determine_files(file)
+      candidates = translate(file)
+      cucumberable = candidates.delete('cucumber')
+      candidates.reject { |candidate| candidate.index('.') }.each do |dir|
+        candidates.reject! { |candidate| candidate.index("#{dir}/") == 0 }
+      end
+      files = candidates.select { |candidate| File.exists? candidate }
+      
+      if files.empty? && !candidates.empty? && !cucumberable 
+        $stderr.puts "doesn't exist: #{candidates.inspect}"
+      end
+      
+      files << 'cucumber' if cucumberable
+      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
+      elsif cucumber_file?(file)
+        candidates << 'cucumber'
+      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'
+          elsif !file.include?("app/views/") || runner.options[:view]
+            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' << 'routing'
+        when 'config/database.yml', 'db/schema.rb', 'spec/factories.rb'
+          candidates << 'models'
+        when 'config/boot.rb', 'config/environment.rb', %r:^config/environments/:, %r:^config/initializers/:, %r:^vendor/:, 'spec/spec_helper.rb'
+          Spork.reload if runner.options[:spork]
+          Celerity.restart if runner.options[:celerity]
+          candidates << 'spec'
+        when %r:^config/:
+          # nothing
+        when %r:^(spec/(spec_helper|shared/.*)|config/(boot|environment(s/test)?))\.rb$:, 'spec/spec.opts', 'spec/fakeweb.rb'
+          candidates << 'spec'
+        else
+          candidates << spec_file
+        end
+      end
+      
+      candidates.map do |candidate|
+        if candidate == 'cucumber'
+          candidate
+        elsif 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
+    def cucumber_file?(file)
+      file =~ /^features\/.+$/
+    end
+  end
+end

data/lib/rspactor/interactor.rb

@@ -0,0 +1,85 @@
+require 'timeout'
+
+module RSpactor
+  class Interactor
+    
+    attr_reader :runner
+    
+    def initialize(runner)
+      @runner = runner
+      ticker
+    end
+    
+    def self.ticker_msg(msg, seconds_to_wait = 3)
+      $stdout.print msg
+      seconds_to_wait.times do
+        $stdout.print('.')
+        $stdout.flush
+        sleep 1
+      end
+      $stdout.puts "\n"
+    end
+    
+    def wait_for_enter_key(msg, seconds_to_wait, clear = runner.options[:clear])
+      begin
+        Timeout::timeout(seconds_to_wait) do
+          system("clear;") if clear
+          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 entry = $stdin.gets
+            case entry
+            when "c\n" # Cucumber: current tagged feature
+              runner.run_cucumber_command
+            when "ca\n" # Cucumber All: ~pending tagged feature
+              runner.run_cucumber_command('~@wip,~@pending')
+            else
+              if wait_for_enter_key("** Running all specs... Hit <enter> again to exit RSpactor", 1)
+                @main_thread.exit
+                exit
+              end
+              runner.run_all_specs
+            end
+          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,88 @@
+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
+    rescue Errno::ENOENT
+      false
+    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/runner.rb

@@ -0,0 +1,193 @@
+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
+    
+    def initialize(dir, options = {})
+      @dir = dir
+      @options = options
+      read_git_head
+    end
+    
+    def start
+      load_dotfile
+      puts "** RSpactor, now watching at '#{dir}'"
+      Spork.start if options[:spork]
+      Celerity.start(dir) if options[:celerity]
+      start_interactor
+      start_listener
+    end
+    
+    def start_interactor
+      @interactor = Interactor.new(self)
+      aborted = @interactor.wait_for_enter_key("** Hit <enter> to skip initial spec & cucumber run", 2, false)
+      @interactor.start_termination_handler
+      unless aborted
+        run_all_specs
+        run_cucumber_command('~@wip,~@pending', false)
+      end
+    end
+    
+    def start_listener
+      @inspector = Inspector.new(self)
+      
+      Listener.new(Inspector::EXTENSIONS) do |files|
+        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_specs
+      run_spec_command(File.join(dir, 'spec'))
+    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_cucumber_command(tags = '@wip:2', clear = @options[:clear])
+      return unless File.exist?(File.join(dir, 'features'))
+      
+      system("clear;") if clear
+      puts "** Running all #{tags} tagged features..."
+      cmd = [ruby_opts, cucumber_runner, cucumber_opts(tags)].flatten.join(' ')
+      @last_run_failed = run_command(cmd)
+      # Workaround for killing jruby process when used with celerity and spork
+      Celerity.kill_jruby if options[:celerity] && options[:spork]
+    end
+    
+    def last_run_failed?
+      @last_run_failed == false
+    end
+    
+    protected
+    
+    def run_command(cmd)
+      system(cmd)
+      $?.success?
+    end
+    
+    def changed_files(files)
+      files = files.inject([]) do |all, file|
+        all.concat inspector.determine_files(file)
+      end
+      unless files.empty?
+        
+        # cucumber features
+        if files.delete('cucumber')
+          run_cucumber_command
+        end
+        
+        # specs files
+        unless files.empty?
+          system("clear;") if @options[:clear]
+          files.uniq!
+          puts files.map { |f| f.to_s.gsub(/#{dir}/, '') }.join("\n")
+          
+          previous_run_failed = last_run_failed?
+          run_spec_command(files)
+          
+          if options[:retry_failed] and previous_run_failed and not last_run_failed?
+            run_all_specs
+          end
+        end
+      end
+    end
+    
+    private
+    
+    def spec_opts
+      if File.exist?('spec/spec.opts')
+        opts = File.read('spec/spec.opts').gsub("\n", ' ')
+      else
+        opts = "--color"
+      end
+      
+      opts << spec_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 cucumber_opts(tags)
+      if File.exist?('features/support/cucumber.opts')
+        opts = File.read('features/support/cucumber.opts').gsub("\n", ' ')
+      else
+        opts = "--color --format progress --drb --no-profile"
+      end
+      
+      opts << " --tags #{tags}"
+      opts << cucumber_formatter_opts
+      opts << " --require features" # because using require option overwrite default require
+      opts << " features"
+      opts
+    end
+    
+    def spec_formatter_opts
+      " --require #{File.dirname(__FILE__)}/../rspec_growler.rb --format RSpecGrowler:STDOUT"
+    end
+    
+    def cucumber_formatter_opts
+      " --require #{File.dirname(__FILE__)}/../cucumber_growler.rb"
+    end
+    
+    def spec_runner
+      if File.exist?("script/spec")
+        "script/spec"
+      else
+        "spec"
+      end
+    end
+    
+    def cucumber_runner
+      if File.exist?("script/cucumber")
+        "script/cucumber"
+      else
+        "cucumber"
+      end
+    end
+    
+    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
+
+# backward compatibility
+Runner = RSpactor::Runner