mislav-rspactor 0.3.0

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/VERSION.yml

@@ -0,0 +1,4 @@
+---
+:major: 0
+:minor: 3
+:patch: 0

data/bin/rspactor

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'rspactor'
+
+Runner.load

data/lib/inspector.rb

@@ -0,0 +1,84 @@
+# 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)
+  
+  def initialize(dir)
+    @root = dir
+  end
+  
+  def determine_spec_files(file)
+    candidates = translate(file)
+    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}"
+          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
+        candidate
+      else
+        '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

data/lib/interactor.rb

@@ -0,0 +1,63 @@
+require 'timeout'
+
+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

data/lib/listener.rb

@@ -0,0 +1,86 @@
+require 'osx/foundation'
+OSX.require_framework '/System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework'
+
+# Some code borrowed from 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

data/lib/resulting.rb

@@ -0,0 +1,47 @@
+class RSpactorFormatter
+  attr_accessor :example_group, :options, :where
+  def initialize(options, where)
+    @options = options
+    @where = where
+  end
+  
+  def dump_summary(duration, example_count, failure_count, pending_count)
+    img = (failure_count == 0) ? "rails_ok.png" : "rails_fail.png"
+    growl "Test Results", "#{example_count} examples, #{failure_count} failures", File.dirname(__FILE__) + "/../asset/#{img}", 0
+  end
+
+  def start(*ignore_these)
+  end
+
+  def add_example_group(*ignore_these)
+  end
+
+  def example_started(*ignore_these)
+  end
+
+  def example_passed(*ignore_these)
+  end
+
+  def example_failed(*ignore_these)
+  end
+  
+  def example_pending( *ignore_these) 
+  end
+
+  def start_dump
+  end
+
+  def dump_failure(*ignore_these)
+  end
+
+  def dump_pending
+  end
+
+  def close
+  end
+  
+  def growl(title, msg, img, pri = 0)
+    system("growlnotify -w -n rspactor --image #{img} -p #{pri} -m #{msg.inspect} #{title} &") 
+  end
+end
+

data/lib/rspactor.rb

@@ -0,0 +1,4 @@
+require 'interactor'
+require 'listener'
+require 'inspector'
+require 'runner'

data/lib/runner.rb

@@ -0,0 +1,82 @@
+require 'inspector'
+require 'interactor'
+require 'listener'
+
+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
+    
+    puts "** RSpactor is now watching at '#{dir}'"
+    
+    aborted = initial_spec_run_abort   
+    @interactor.start_termination_handler
+    run_all_specs unless aborted
+    
+    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)
+    end.run(dir)
+  end
+  
+  def self.initial_spec_run_abort
+    @interactor.wait_for_enter_key("** Hit <enter> to skip initial spec run", 3)
+  end
+
+  def self.run_all_specs
+    run_spec_command('spec')
+  end
+
+  def self.run_spec_command(paths)
+    paths = Array(paths)
+    return if paths.empty?
+    run_command [ruby_opts, spec_runner, paths, spec_opts].flatten.join(' ')
+  end
+  
+  def self.run_command(cmd)
+    system(cmd)
+  end
+  
+  def self.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 self.formatter_opts
+    "-r #{File.dirname(__FILE__)}/resulting.rb -f RSpactorFormatter:STDOUT"
+  end
+  
+  def self.spec_runner
+    if File.exist?("script/spec")
+      "script/spec"
+    else
+      "spec"
+    end
+  end
+  
+  def self.ruby_opts
+    other = ENV['RUBYOPT'] ? " #{ENV['RUBYOPT']}" : ''
+    %(RUBYOPT='-Ilib:spec#{other}')
+  end
+end

data/spec/inspector_spec.rb

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

data/spec/listener_spec.rb

@@ -0,0 +1,35 @@
+require 'listener'
+
+describe Listener do
+  before(:all) do
+    @listener = Listener.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 without extension" do
+    @listener.ignore_file?('/project/foo.rb').should_not be
+  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/runner_spec.rb

@@ -0,0 +1,138 @@
+require 'runner'
+
+class ::Runner
+  def self.run_command(cmd)
+    # never shell out in tests
+    cmd
+  end
+end
+
+describe ::Runner do
+  
+  before(:all) do
+    @runner = ::Runner
+  end
+  
+  def with_env(name, value)
+    old_value = ENV[name]
+    ENV[name] = value
+    begin
+      yield
+    ensure
+      ENV[name] = old_value
+    end
+  end
+  
+  describe "setup" do
+    before(:each) do
+      Dir.stub!(:pwd).and_return('/my/path')
+      File.stub!(:exists?).and_return(false)
+      @runner.stub!(:puts)
+      Inspector.stub!(:new)
+      Interactor.stub!(:new).and_return(mock('Interactor').as_null_object)
+      Listener.stub!(:new).and_return(mock('Listener').as_null_object)
+    end
+    
+    def setup
+      @runner.load
+    end
+    
+    it "should initialize Inspector" do
+      Inspector.should_receive(:new).with('/my/path')
+      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)
+      Interactor.should_receive(:new).and_return(interactor)
+      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)
+      Interactor.should_receive(:new).and_return(interactor)
+      @runner.should_receive(:run_spec_command).with('spec')
+      setup
+    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)
+      Interactor.should_receive(:new).and_return(interactor)
+      @runner.should_not_receive(:run_spec_command)
+      setup
+    end
+  
+    it "should run Listener" do
+      listener = mock('Listener')
+      listener.should_receive(:run).with('/my/path')
+      Listener.should_receive(:new).with(instance_of(Array)).and_return(listener)
+      setup
+    end
+  
+    it "should output 'watching' message on start" do
+      @runner.should_receive(:puts).with("** RSpactor is now watching at '/my/path'")
+      setup
+    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
+  end
+  
+  describe "#run_spec_command" do
+    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:spec' ")
+      end
+    end
+    
+    it "should concat existing RUBYOPTs" do
+      with_rubyopt('-rubygems -w') do
+        run('foo').should include("RUBYOPT='-Ilib:spec -rubygems -w' ")
+      end
+    end
+    
+    it "should include growl formatter" do
+      run('foo').should include(' -f RSpactorFormatter: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
+  end
+  
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: mislav-rspactor
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- "Mislav Marohni\xC4\x87"
+- Andreas Wolff
+- Pelle Braendgaard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-17 00:00:00 -07:00
+default_executable: rspactor
+dependencies: []
+
+description: 
+email: mislav.marohnic@gmail.com
+executables: 
+- rspactor
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+files: 
+- VERSION.yml
+- bin/rspactor
+- lib/inspector.rb
+- lib/interactor.rb
+- lib/listener.rb
+- lib/resulting.rb
+- lib/rspactor.rb
+- lib/runner.rb
+- spec/inspector_spec.rb
+- spec/listener_spec.rb
+- spec/runner_spec.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/mislav/rspactor
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+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: 2
+summary: RSpactor is a command line tool to automatically run your changed specs (much like autotest).
+test_files: []
+