rspactor 0.6.4 → 0.7.0.beta.1

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Mislav Marohnić
+Copyright (c) 2010 Thibaud Guillaume-Gentil
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -17,4 +17,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -1,23 +1,70 @@
-=== Dependencies
+= RSpactor
 
-RubyCocoa is needed (you can help to switch to ruby-fsevent, see branches)
+RSpactor allows to automatically & intelligently launch your specs when your files are modified.
+Version 0.7.x is a complete rewrite, RubyCocoa is no more needed, FSEvents are supported from scratch.
 
-  Installing ruby-cocoa with rvm: http://gist.github.com/294465
+== Features
 
-=== Install
+* FSEvent support (without RubyCocoa!)
+* RSpec 2.0 support (from beta.14)
+* Bundler support
+* Super fast change detection
+* Automatic _spec.rb files detection (even new file created, unlike watchr)
+* Growl notification (please install {growlnotify}[http://growl.info/documentation/growlnotify.php])
 
-  gem install rspactor
+== Install
 
-=== Usage
+At the moment, only Mac OS X (10.5+) is supported. Tested on ruby 1.8.7 & 1.9.2dev.
 
-  cd /path/to/rails/root/
-  rspactor
+Install the gem:
 
-=== Command Line Options
+    gem install rspactor
 
-* <code> --coral    </code> use coral
-* <code> --drb      </code> use spork
-* <code> --view     </code> run view specs
-* <code> --clear    </code> clear before each run
-* <code> --skip     </code> skip initial test run
-* <code> --run_in   </code>
+If you are using Bundler, please add it to your Gemfile (inside test group):
+
+    gem 'rspactor', '>= 0.7.beta.1'
+
+== Usage
+
+Just launch RSpactor inside your ruby/rails project with:
+
+    rspactor
+
+Options list is available with:
+
+    rspactor -h
+
+Signal handlers are now used to interact with RSpactor:
+
+* Ctrl-C => Quit RSpactor or quick abort running spec(s)
+* Ctrl-/ => Running all specs
+
+== TODO
+
+* Specific files (spec_helper, factories, fixtures...) inspections
+* RSpec 1.3 support
+* Inotify support (linux)
+* Spork support (when {this issue}[http://github.com/timcharper/spork/issues#issue/37] will be resolved)
+* Cucumber support (if really needed? {Steak}[http://github.com/cavalle/steak] works fine.)
+* Other ideas?
+
+== Development
+
+* Source hosted at {GitHub}[http://github.com/thibaudgg/rspactor].
+* Report issues/Questions/Feature requests on {GitHub Issues}[http://github.com/thibaudgg/rspactor/issues]
+
+Pull requests are very welcome! Make sure your patches are well tested. Please create a topic branch for every separate change
+you make.
+
+== Authors
+
+From version 0.7.x was completely rewritten by {Thibaud Guillaume-Gentil}[http://github.com/thibaudgg].
+
+Older versions authors are:
+
+* {Mislav Marohnić}[http://github.com/mislav]
+* {Andreas Wolff}[http://github.com/phunkwork]
+* {Pelle Braendgaard}[http://github.com/pelle]
+* {Thibaud Guillaume-Gentil}[http://github.com/thibaudgg]
+
+Thanks to {Giovanni Cangiani}[http://github.com/multiscan] for the IO.open/FSEvent trick & {Rémy Coutable}[http://github.com/rymai] for beta testing.

data/bin/rspactor

@@ -1,11 +1,12 @@
 #!/usr/bin/env ruby
-require 'rspactor/runner'
+require 'trollop'
+require 'rspactor'
+require 'rspactor/version'
 
-RSpactor::Runner.start({
-  :coral => ARGV.delete('--coral'),
-  :spork => ARGV.delete('--drb'),
-  :view => ARGV.delete('--view'), # by default, rspactor didn't catch specs view
-  :clear => ARGV.delete('--clear'),
-  :skip => ARGV.delete('--skip'),
-  :run_in => ARGV.last
-})
+options = Trollop::options do
+  version RSpactor::VERSION
+  
+  opt :clear, "Clear the console beetween each spec(s) run"
+end
+
+RSpactor.start(options)

data/ext/fsevent/extconf.rb

@@ -0,0 +1,28 @@
+# Workaround to make Rubygems believe it builds a native gem
+
+def emulate_extension_install(extension_name)
+  File.open('Makefile', 'w') { |f| f.write "all:\n\ninstall:\n\n" }
+  File.open('make', 'w') do |f|
+    f.write '#!/bin/sh'
+    f.chmod f.stat.mode | 0111
+  end
+  File.open(extension_name + '.so', 'w') {}
+  File.open(extension_name + '.dll', 'w') {}
+  File.open('nmake.bat', 'w') { |f| }
+end
+
+emulate_extension_install('fsevent')
+
+# Compile the actual fsevent_watch binary
+
+raise "Only Darwin (Mac OS X) systems are supported for the moment" unless `uname -s`.chomp == 'Darwin'
+
+GEM_ROOT       = File.expand_path(File.join('..', '..'))
+DARWIN_VERSION = `uname -r`.to_i
+SDK_VERSION    = { 9 => '10.5', 10 => '10.6', 11 => '10.7' }[DARWIN_VERSION]
+
+raise "Darwin #{DARWIN_VERSION} is not supported" unless SDK_VERSION
+
+`CFLAGS='-isysroot /Developer/SDKs/MacOSX#{SDK_VERSION}.sdk -mmacosx-version-min=#{SDK_VERSION}' /usr/bin/gcc -framework CoreServices -o "#{GEM_ROOT}/bin/fsevent_watch" fsevent_watch.c`
+
+raise "Compilation of fsevent_watch failed (see README)" unless File.executable?("#{GEM_ROOT}/bin/fsevent_watch")

data/ext/fsevent/fsevent_watch.c

@@ -0,0 +1,44 @@
+#include <CoreServices/CoreServices.h>
+
+void callback(ConstFSEventStreamRef streamRef,
+  void *clientCallBackInfo,
+  size_t numEvents,
+  void *eventPaths,
+  const FSEventStreamEventFlags eventFlags[],
+  const FSEventStreamEventId eventIds[]
+) {
+  // Print modified dirs
+  int i;
+  char **paths = eventPaths;
+  for (i = 0; i < numEvents; i++) {
+    printf(paths[i]);
+    printf(" ");
+  }
+  printf("\n");
+  fflush(stdout);
+}
+
+int main (int argc, const char * argv[]) {
+  // Create event stream
+  CFStringRef pathToWatch = CFStringCreateWithCString(kCFAllocatorDefault, argv[1], kCFStringEncodingUTF8);
+  CFArrayRef pathsToWatch = CFArrayCreate(NULL, (const void **)&pathToWatch, 1, NULL);  
+  void *callbackInfo = NULL;
+  FSEventStreamRef stream;
+  CFAbsoluteTime latency = 0.5;
+  stream = FSEventStreamCreate(
+    kCFAllocatorDefault,
+    callback,
+    callbackInfo,
+    pathsToWatch,
+    kFSEventStreamEventIdSinceNow,
+    latency,
+    kFSEventStreamCreateFlagNone
+  );
+  
+  // Add stream to run loop
+  FSEventStreamScheduleWithRunLoop(stream, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);
+  FSEventStreamStart(stream);
+  CFRunLoopRun();
+  
+  return 2;
+}

data/lib/growl/growl_formatter.rb

@@ -0,0 +1,35 @@
+require 'rspec/core/formatters/base_formatter'
+require 'growl'
+
+class GrowlFormatter < RSpec::Core::Formatters::ProgressFormatter
+  
+  def dump_summary
+    super
+    failure_count = failed_examples.size
+    pending_count = pending_examples.size
+    
+    icon = if failure_count > 0
+      'failed'
+    elsif pending_count > 0
+      'pending'
+    else
+      'success'
+    end
+    
+    message = "#{@example_count} examples, #{failure_count} failures"
+    if pending_count > 0
+      message << " (#{pending_count} pending)"
+    end
+    message << "\nin #{format_seconds(duration)} seconds"
+    
+    Growl.notify message, :title => "RSpec results", :icon => image_path(icon)
+  end
+  
+private
+  
+  # failed | pending | success
+  def image_path(icon)
+    File.expand_path(File.dirname(__FILE__) + "/../../images/#{icon}.png")
+  end
+  
+end

data/lib/rspactor/inspector.rb

@@ -1,118 +1,52 @@
-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')
-      runner.spork.reload if candidates.delete('spork') && runner.spork?
+  module Inspector
+    class << self
+      attr_reader :spec_paths
       
-      candidates.reject { |candidate| candidate.index('.') }.each do |dir|
-        candidates.reject! { |candidate| candidate.index("#{dir}/") == 0 }
+      def determine_spec_paths(files)
+        @spec_paths, @spec_files = [], nil
+        files.each { |file| translate(file) }
+        compact_spec_paths!
       end
-      files = candidates.select { |candidate| File.exists? candidate }
       
-      if files.empty? && !candidates.empty? && !cucumberable 
-        $stderr.puts "doesn't exist: #{candidates.inspect}"
+      def spec_paths?
+        @spec_paths.size > 0
       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 = []
+    private
       
-      if spec_file?(file)
-        candidates << file
-      elsif cucumber_file?(file)
-        candidates << 'cucumber'
-        candidates << 'spork' if file =~ /^features\/support\//
-      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'
-            candidates << 'views' if runner.options[:view]
-          elsif file.include?("app/views/")
-            if runner.options[:view]
-              candidates << spec_file.sub('app/', '')
-              if file =~ %r:^app/(views/.+\.[a-z]+)\.[a-z]+$:
-                candidates << append_spec_file_extension($1)
-              end
-            end
-          else
-            candidates << spec_file.sub('app/', '')
-            if 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' << 'routing'
-          candidates << 'views' if runner.options[:view]
-        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'
-          candidates << 'spork'
-          candidates << 'spec'
-        when %r:^config/:
-          # nothing
-        when %r:^(spec/(spec_helper|shared/.*)|config/(boot|environment(s/test)?))\.rb$:, 'spec/spec.opts', 'spec/fakewebs.rb'
-          candidates << 'spec'
+      def translate(file)
+        if spec_file?(file)
+          @spec_paths << file
         else
-          candidates << spec_file
+          spec_file = append_spec_file_extension(file)
+          case file
+          when %r:^lib/:
+            @spec_paths << @spec_files.delete(spec_file.gsub(/^lib/, 'spec'))
+            @spec_paths << @spec_files.delete(spec_file.gsub(/^lib/, 'spec/lib'))
+          when %r:^app/:
+            @spec_paths << @spec_files.delete(spec_file.gsub(/^app/, 'spec'))
+          end
         end
       end
       
-      candidates.map do |candidate|
-        if candidate == 'cucumber' || candidate == 'spork'
-          candidate
-        elsif candidate.index('spec') == 0
-          File.join(root, candidate)
-        else
-          File.join(root, 'spec', candidate)
-        end
+      def compact_spec_paths!
+        @spec_paths.uniq!
+        @spec_paths.compact!
       end
-    end
-    
-    def append_spec_file_extension(file)
-      if File.extname(file) == ".rb"
-        file.sub(/.rb$/, "_spec.rb")
-      else
-        file + "_spec.rb"
+      
+      def spec_file?(file)
+        spec_files.include?(file)
       end
-    end
-    
-    def spec_file?(file)
-      file =~ /^spec\/.+_spec.rb$/
-    end
-    def cucumber_file?(file)
-      file =~ /^features\/.+$/
+      
+      def spec_files
+        @spec_files ||= Dir.glob("spec/**/*_spec.rb")
+      end
+      
+      def append_spec_file_extension(file)
+        file.sub(/(\..*)$/, "_spec.rb")
+      end
+      
     end
   end
 end

data/lib/rspactor/interactor.rb

@@ -1,101 +1,33 @@
-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, &block)
-      $stdout.print msg
-      if block
-        @yielding_ticker = true
-        Thread.new do
-          loop do
-            $stdout.print('.') if @yielding_ticker == true
-            $stdout.flush
-            sleep 1.0
-          end
-        end
-        
-        yield
-        @yielding_ticker = false
-      else
-        seconds_to_wait.times do
-          $stdout.print('.')
-          $stdout.flush
-          sleep 1
-        end
-      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
+  module Interactor
+    class << self
+      
+      def init_signal_traps
+        # Ctrl-/
+        Signal.trap('QUIT') do
+          RSpactor.listener.stop
+          RSpactor.runner.start(:all => true)
+          RSpactor.listener.start
         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')
-            when "r\n"
-              runner.spork.reload if runner.spork
-            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
+        # Ctrl-C
+        Signal.trap('INT') do
+          if RSpactor.runner.run?
+            UI.info "RSpec run canceled", :reset => true, :clear => RSpactor.options[:clear]
+            RSpactor.runner.stop
+          else
+            UI.info "Bye bye...", :reset => true
+            abort("\n")
           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
+        # Ctrl-Z
+        Signal.trap('TSTP') do
+          # UI.info "Reloading Spork...", :reset => true
+          RSpactor.listener.stop
+          # # Reload Spork
+          RSpactor.listener.start
         end
       end
-    end
-    
-    def write(msg)
-      $stdout.print(msg)
-      $stdout.flush
+      
     end
   end
 end

data/lib/rspactor/listener.rb

@@ -1,88 +1,59 @@
-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
+    EXTENSIONS = %w[rb erb builder haml yml]
     
-    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
+    attr_reader :last_event, :callback, :pipe
+    
+    def initialize
+      update_last_event
     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
+    def watch(&block)
+      @callback = block
     end
     
-    def timestamp_checked
-      @last_check = Time.now
+    def start
+      @pipe = IO.popen("#{bin_path}/fsevent_watch .")
+      watch_change
     end
     
-    def split_paths(paths, num_events)
-      paths.regard_as('*')
-      rpaths = []
-      num_events.times { |i| rpaths << paths[i] }
-      rpaths
+    def stop
+      Process.kill("HUP", pipe.pid) if pipe
     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)
+  private
+    
+    def watch_change
+      while !pipe.eof?
+        if line = pipe.readline
+          modified_dirs = line.split(" ")
+          files = modified_files(modified_dirs)
+          update_last_event
+          callback.call(files)
         end
       end
-      changed_files
     end
     
-    def file_changed?(file)
-      File.stat(file).mtime > last_check
-    rescue Errno::ENOENT
-      false
+    def modified_files(dirs)
+      files = potentially_modified_files(dirs).select { |file| recent_file?(file) }
+      files.map! { |file| file.gsub("#{Dir.pwd}/", '') }
     end
     
-    def ignore_path?(path)
-      path =~ /(?:^|\/)\.(git|svn)/
+    def potentially_modified_files(dirs)
+      Dir.glob(dirs.map { |dir| "#{dir}*.{#{EXTENSIONS.join(',')}}" })
     end
     
-    def ignore_file?(file)
-      File.basename(file).index('.') == 0 or not valid_extension?(file)
+    def recent_file?(file)
+      File.mtime(file) >= last_event
     end
     
-    def file_extension(file)
-      file =~ /\.(\w+)$/ and $1
+    def update_last_event
+      @last_event = Time.now
     end
     
-    def valid_extension?(file)
-      valid_extensions.nil? or valid_extensions.include?(file_extension(file))
+    def bin_path
+      File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin'))
     end
+    
   end
 end