kicker 2.1.0 → 2.2.0

data/lib/kicker/recipes/ruby.rb

@@ -0,0 +1,155 @@
+class Ruby
+  class << self
+    # Assigns the type of tests to run. Eg: `test' or `spec'.
+    attr_writer :test_type
+    
+    # Returns the type of tests to run. Eg: `test' or `spec'.
+    #
+    # Defaults to `test' if no `spec' directory exists.
+    def test_type
+      @test_type ||= File.exist?('spec') ? 'spec' : 'test'
+    end
+    
+    # Assigns the ruby command to run the tests with. Eg: `ruby19' or `specrb'.
+    #
+    # This can be set from the command line with the `-b' or `--ruby' options.
+    attr_writer :runner_bin
+    
+    # Returns the ruby command to run the tests with. Eg: `ruby' or `spec'.
+    #
+    # Defaults to `ruby' if test_type is `test' and `spec' if test_type is
+    # `spec'.
+    def runner_bin
+      @runner_bin ||= test_type == 'test' ? 'ruby' : 'spec'
+    end
+    
+    # Assigns the root directory of where test cases will be looked up.
+    attr_writer :test_cases_root
+    
+    # Returns the root directory of where test cases will be looked up.
+    #
+    # Defaults to the value of test_type. Eg: `test' or `spec'.
+    def test_cases_root
+      @test_cases_root ||= test_type
+    end
+    
+    attr_writer :test_options #:nodoc:
+    
+    # Assigns extra options that are to be passed on to the runner_bin.
+    #
+    #   Ruby.test_options << '-I ./lib/foo'
+    def test_options
+      @test_options ||= []
+    end
+    
+    # Runs the given tests, if there are any, with the method defined by
+    # test_type. If test_type is `test' the run_with_test_runner method is
+    # used. The same applies when test_type is `spec'.
+    def run_tests(tests)
+      send("run_with_#{test_type}_runner", tests) unless tests.empty?
+    end
+    
+    def test_runner_command(tests)
+      "#{runner_bin} #{test_options.join(' ')} -r #{tests.join(' -r ')} -e ''"
+    end
+    
+    # Runs the given tests with `ruby' as unit-test tests.
+    #
+    # If you want to adjust the logging, stdout and growl, override this, call
+    # test_runner_command with the tests to get the command and call execute
+    # with the custom logging block.
+    def run_with_test_runner(tests)
+      execute(test_runner_command(tests)) do |status|
+        if status.after? && status.growl?
+          status.output.split("\n").last
+        end
+      end
+    end
+    
+    def spec_runner_command(tests)
+      "#{runner_bin} #{test_options.join(' ')} #{tests.join(' ')}"
+    end
+    
+    # Runs the given tests with `spec' as RSpec tests.
+    #
+    # If you want to adjust the logging, stdout and growl, override this, call
+    # spec_runner_command with the tests to get the command and call execute
+    # with the custom logging block.
+    def run_with_spec_runner(tests)
+      execute(spec_runner_command(tests)) do |status|
+        if status.after? && status.growl?
+          status.output.split("\n").last
+        end
+      end
+    end
+  end
+  
+  def self.call(files) #:nodoc:
+    handler = new(files)
+    handler.handle!
+    run_tests(handler.tests)
+  end
+  
+  # The list of collected tests.
+  attr_reader :tests
+  
+  def initialize(files) #:nodoc:
+    @files = files
+    @tests = []
+  end
+  
+  # A shortcut to Ruby.test_type.
+  def test_type
+    self.class.test_type
+  end
+  
+  # A shortcut to Ruby.runner_bin.
+  def runner_bin
+    self.class.runner_bin
+  end
+  
+  # A shortcut to Ruby.test_cases_root.
+  def test_cases_root
+    self.class.test_cases_root
+  end
+  
+  # Returns the file for +name+ if it exists.
+  #
+  #   test_file('foo') # => "test/foo_test.rb"
+  #   test_file('foo/bar') # => "test/foo/bar_test.rb"
+  #   test_file('does/not/exist') # => nil
+  def test_file(name)
+    file = File.join(test_cases_root, "#{name}_#{test_type}.rb")
+    file if File.exist?(file)
+  end
+  
+  # This method is called to collect tests. Override this if you're subclassing
+  # and make sure to call +super+.
+  def handle!
+    @tests.concat(@files.take_and_map do |file|
+      case file
+      # Match any ruby test file
+      when /^#{test_cases_root}\/.+_#{test_type}\.rb$/
+        file
+      
+      # A file such as ./lib/namespace/foo.rb is mapped to:
+      # * ./test/namespace/foo_test.rb
+      # * ./test/foo_test.rb
+      when /^lib\/(.+)\.rb$/
+        if namespaced = test_file($1)
+          namespaced
+        elsif in_test_root = test_file(File.basename(file, '.rb'))
+          in_test_root
+        end
+      end
+    end)
+  end
+end
+
+options.on('-b', '--ruby [PATH]', "Use an alternate Ruby binary for spawned test runners. (Default is `ruby')") do |command|
+  Ruby.runner_bin = command
+end
+
+recipe :ruby do
+  process Ruby
+end

data/lib/kicker/utils.rb

@@ -2,25 +2,13 @@ class Kicker
   module Utils #:nodoc:
     extend self
     
-    def execute(command)
+    def execute(command, &block)
       @last_command = command
+      status = LogStatusHelper.new(block, command)
       
-      log "Change occured, executing command: #{command}"
-      Kicker.growl(GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured, executing command:', command) if Kicker.use_growl
-      
-      output = `#{command}`
-      output.strip.split("\n").each { |line| log "  #{line}" }
-      
-      log "Command #{last_command_succeeded? ? 'succeeded' : "failed (#{last_command_status})"}"
-      
-      if Kicker.use_growl
-        if last_command_succeeded?
-          callback = Kicker.growl_command.nil? ? GROWL_DEFAULT_CALLBACK : lambda { system(Kicker.growl_command) }
-          Kicker.growl(GROWL_NOTIFICATIONS[:succeeded], "Kicker: Command succeeded", output, &callback)
-        else
-          Kicker.growl(GROWL_NOTIFICATIONS[:failed], "Kicker: Command failed (#{last_command_status})", output, &GROWL_DEFAULT_CALLBACK)
-        end
-      end
+      will_execute_command(status)
+      status.result(`#{command}`, last_command_succeeded?, last_command_status)
+      did_execute_command(status)
     end
     
     def last_command
@@ -28,15 +16,14 @@ class Kicker
     end
     
     def log(message)
-      puts "[#{Time.now}] #{message}"
-    end
-    
-    def run_ruby_tests(tests)
-      execute "ruby -r #{tests.join(' -r ')} -e ''" unless tests.empty?
+      if Kicker.quiet
+        puts message
+      else
+        now = Time.now
+        puts "#{now.strftime('%H:%M:%S')}.#{now.usec.to_s[0,2]} | #{message}"
+      end
     end
     
-    private
-    
     def last_command_succeeded?
       $?.success?
     end
@@ -44,6 +31,29 @@ class Kicker
     def last_command_status
       $?.to_i
     end
+    
+    private
+    
+    def will_execute_command(status)
+      message = status.call(:stdout) || "Executing: #{status.command}"
+      log(message) unless message.empty?
+      Kicker::Growl.change_occured(status) if Kicker::Growl.use? && !Kicker.silent?
+    end
+    
+    def did_execute_command(status)
+      if message = status.call(:stdout)
+        log(message) unless message.empty?
+      else
+        if status.success? && Kicker.silent?
+          log 'Success'
+        else
+          puts("\n#{status.output.strip}\n\n")
+          log(status.success? ? "Success" : "Failed (#{status.exit_code})")
+        end
+      end
+      
+      Kicker::Growl.result(status) if Kicker::Growl.use?
+    end
   end
 end
 
@@ -54,18 +64,12 @@ module Kernel
   end
   
   # Executes the +command+, logs the output, and optionally growls.
-  def execute(command)
-    Kicker::Utils.execute(command)
+  def execute(command, &block)
+    Kicker::Utils.execute(command, &block)
   end
   
   # Returns the last executed command.
   def last_command
     Kicker::Utils.last_command
   end
-  
-  # A convenience method that takes an array of Ruby test files and runs them
-  # collectively.
-  def run_ruby_tests(tests)
-    Kicker::Utils.run_ruby_tests(tests)
-  end
 end

data/test/callback_chain_test.rb

@@ -12,7 +12,7 @@ describe "Kicker, concerning its callback chains" do
   end
   
   it "should be accessible by an instance" do
-    kicker = Kicker.new({})
+    kicker = Kicker.new
     
     @chains.each do |chain|
       kicker.send(chain).should == Kicker.send(chain)

data/test/core_ext_test.rb

@@ -2,12 +2,12 @@ require File.expand_path('../test_helper', __FILE__)
 
 describe "Array#take_and_map" do
   before do
-    @array = %w{ foo bar baz }
+    @array = %w{ foo bar baz foo/bar.baz foo/bar/baz }
   end
   
   it "should remove elements from the array for which the block evaluates to true" do
     @array.take_and_map { |x| x =~ /^ba/ }
-    @array.should == %w{ foo }
+    @array.should == %w{ foo foo/bar.baz foo/bar/baz }
   end
   
   it "should return a new array of the return values of each block call that evaluates to true" do
@@ -21,8 +21,18 @@ describe "Array#take_and_map" do
   end
   
   it "should not flatten and compact the result array if specified" do
-    @array.take_and_map(false) do |x|
+    @array.take_and_map(nil, false) do |x|
       x =~ /^ba/ ? %w{ f o o } : [nil]
-    end.should == [[nil], %w{ f o o }, %w{ f o o }]
+    end.should == [[nil], %w{ f o o }, %w{ f o o }, [nil], [nil]]
   end
-end
+  
+  it "should take only files matching the pattern" do
+    @array.take_and_map('**/*') { |x| x.reverse }.should ==
+      %w{ foo/bar.baz foo/bar/baz }.map { |s| s.reverse }
+  end
+  
+  it "should not remove files not matching the pattern" do
+    @array.take_and_map('**/*') { |x| x }
+    @array.should == %w{ foo bar baz }
+  end
+end

data/test/filesystem_change_test.rb

@@ -6,7 +6,7 @@ describe "Kicker, when a change occurs" do
     
     Kicker.any_instance.stubs(:last_command_succeeded?).returns(true)
     Kicker.any_instance.stubs(:log)
-    @kicker = Kicker.new({})
+    @kicker = Kicker.new
   end
   
   it "should store the current time as when the last change occurred" do

data/test/growl_test.rb

@@ -0,0 +1,85 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Kicker::Growl" do
+  before do
+    @growler = Kicker::Growl
+  end
+  
+  after do
+    Kicker.silent = false
+  end
+  
+  it "should growl that an event occurred" do
+    status = Kicker::LogStatusHelper.new(nil, 'ls -l')
+    @growler.expects(:growl).with(@growler.notifications[:change], 'Kicker: Executing', 'ls -l')
+    @growler.change_occured(status)
+  end
+  
+  it "should growl that an event occurred with the status callback" do
+    status = Kicker::LogStatusHelper.new(proc { |s| 'foo' if s.growl? }, 'ls -l')
+    @growler.expects(:growl).with(@growler.notifications[:change], 'Kicker: Executing', 'foo')
+    @growler.change_occured(status)
+  end
+  
+  it "should use the default click callback if a command succeeded and no user callback is defined" do
+    status = Kicker::LogStatusHelper.new(nil, 'ls -l')
+    status.result("line 1\nline 2", true, 0)
+    
+    OSX::NSWorkspace.sharedWorkspace.expects(:launchApplication).with('Terminal')
+    @growler.expects(:growl).with(
+      @growler.notifications[:succeeded],
+      'Kicker: Success',
+      "line 1\nline 2"
+    ).yields
+    
+    @growler.result(status)
+  end
+  
+  it "should use the default click callback if a command failed and no user callback is defined" do
+    status = Kicker::LogStatusHelper.new(nil, 'ls -l')
+    status.result("line 1\nline 2", false, 123)
+    
+    OSX::NSWorkspace.sharedWorkspace.expects(:launchApplication).with('Terminal')
+    @growler.expects(:growl).with(
+      @growler.notifications[:failed],
+      'Kicker: Failed (123)',
+      "line 1\nline 2"
+    ).yields
+    
+    @growler.failed(status)
+  end
+  
+  it "should only growl that the command succeeded in silent mode" do
+    Kicker.silent = true
+    status = Kicker::LogStatusHelper.new(nil, 'ls -l')
+    status.result("line 1\nline 2", true, 0)
+    
+    @growler.expects(:growl).with(@growler.notifications[:succeeded], 'Kicker: Success', '')
+    @growler.result(status)
+  end
+  
+  it "should only growl that the command failed in silent mode" do
+    Kicker.silent = true
+    status = Kicker::LogStatusHelper.new(nil, 'ls -l')
+    status.result("line 1\nline 2", false, 123)
+    
+    @growler.expects(:growl).with(@growler.notifications[:failed], 'Kicker: Failed (123)', '')
+    @growler.failed(status)
+  end
+  
+  it "should growl that the command succeeded with the status callback" do
+    status = Kicker::LogStatusHelper.new(proc { |s| 'foo' if s.growl? }, 'ls -l')
+    status.result("line 1\nline 2", true, 0)
+    
+    @growler.expects(:growl).with(@growler.notifications[:succeeded], 'Kicker: Success', 'foo')
+    @growler.succeeded(status)
+  end
+  
+  it "should growl that the command failed with the status callback" do
+    status = Kicker::LogStatusHelper.new(proc { |s| 'foo' if s.growl? }, 'ls -l')
+    status.result("line 1\nline 2", false, 123)
+    
+    @growler.expects(:growl).with(@growler.notifications[:failed], 'Kicker: Failed (123)', 'foo')
+    @growler.failed(status)
+  end
+end

data/test/initialization_test.rb

@@ -7,87 +7,55 @@ describe "Kicker" do
     Kicker.any_instance.stubs(:start)
   end
   
-  it "should add kicker/recipes to the load path" do
-    $:.should.include File.expand_path('../../lib/kicker/recipes', __FILE__)
-  end
-  
-  if File.exist?(File.expand_path('~/.kick'))
-    it "should add ~/.kick to the load path" do
-      $:.should.include File.expand_path('~/.kick')
-    end
-  else
-    puts "[!] ~/.kick does not exist, skipping an example."
-  end
-  
   it "should return the default paths to watch" do
     Kicker.paths.should == %w{ . }
   end
   
-  it "should check if a .kick file exists and if so load it and add the ReloadDotKick handler" do
-    File.expects(:exist?).with('.kick').returns(true)
-    Kicker.expects(:require).with('dot_kick')
-    ReloadDotKick.expects(:save_state)
-    Kicker.expects(:load).with('.kick')
-    Kicker.run
-  end
-  
-  it "should check if a recipe exists and load it" do
-    Kicker.stubs(:load_dot_kick)
-    
-    Kicker.expects(:require).with('rails')
-    Kicker.expects(:require).with('ignore')
-    Kicker.run(%w{ -r rails -r ignore })
-  end
-  
-  it "should raise if a recipe does not exist" do
-    Kicker.expects(:require).never
-    lambda { Kicker.run(%w{ -r foobar -r rails }) }.should.raise
+  it "should default the FSEvents latency to 1" do
+    Kicker.latency.should == 1
   end
 end
 
 describe "Kicker, when initializing" do
-  before do
-    @now = Time.now
-    Time.stubs(:now).returns(@now)
-    
-    @kicker = Kicker.new(:paths => %w{ /some/dir a/relative/path })
+  after do
+    Kicker.paths = %w{ . }
   end
   
   it "should return the extended paths to watch" do
-    @kicker.paths.should == ['/some/dir', File.expand_path('a/relative/path')]
+    Kicker.paths = %w{ /some/dir a/relative/path }
+    Kicker.new.paths.should == ['/some/dir', File.expand_path('a/relative/path')]
   end
   
   it "should have assigned the current time to last_event_processed_at" do
-    @kicker.last_event_processed_at.should == @now
+    now = Time.now; Time.stubs(:now).returns(now)
+    Kicker.new.last_event_processed_at.should == now
   end
   
   it "should use the default paths if no paths were given" do
-    Kicker.new({}).paths.should == [File.expand_path('.')]
-  end
-  
-  it "should use the default FSEvents latency if none was given" do
-    @kicker.latency.should == 1
-  end
-  
-  it "should use the given FSEvents latency if one was given" do
-    Kicker.new(:latency => 3.5).latency.should == 3.5
+    Kicker.new.paths.should == [File.expand_path('.')]
   end
 end
 
 describe "Kicker, when starting" do
   before do
-    @kicker = Kicker.new(:paths => %w{ /some/file.rb })
+    Kicker.paths = %w{ /some/file.rb }
+    @kicker = Kicker.new
     @kicker.stubs(:log)
+    @kicker.startup_chain.stubs(:call)
     Rucola::FSEvents.stubs(:start_watching)
     OSX.stubs(:CFRunLoopRun)
   end
   
+  after do
+    Kicker.latency = 1
+    Kicker.paths = %w{ . }
+  end
+  
   it "should show the usage banner and exit when there are no callbacks defined at all" do
     @kicker.stubs(:validate_paths_exist!)
-    Kicker.stubs(:process_chain).returns([])
-    Kicker.stubs(:pre_process_chain).returns([])
+    Kicker.stubs(:startup_chain).returns(Kicker::CallbackChain.new)
     
-    Kicker::OPTION_PARSER_CALLBACK.stubs(:call).returns(mock('OptionParser', :help => 'help'))
+    Kicker::Options.stubs(:parser).returns(mock('OptionParser', :help => 'help'))
     @kicker.expects(:puts).with("help")
     @kicker.expects(:exit)
     
@@ -106,7 +74,8 @@ describe "Kicker, when starting" do
   it "should start a FSEvents stream with the assigned latency" do
     @kicker.stubs(:validate_options!)
     
-    Rucola::FSEvents.expects(:start_watching).with(['/some'], :latency => @kicker.latency)
+    Kicker.latency = 2.34
+    Rucola::FSEvents.expects(:start_watching).with(['/some'], :latency => 2.34)
     @kicker.start
   end
   
@@ -114,7 +83,7 @@ describe "Kicker, when starting" do
     @kicker.stubs(:validate_options!)
     File.stubs(:directory?).with('/some/file.rb').returns(false)
     
-    Rucola::FSEvents.expects(:start_watching).with(['/some'], :latency => @kicker.latency)
+    Rucola::FSEvents.expects(:start_watching).with(['/some'], :latency => Kicker.latency)
     @kicker.start
   end
   
@@ -142,15 +111,15 @@ describe "Kicker, when starting" do
   
   it "should register with growl if growl should be used" do
     @kicker.stubs(:validate_options!)
-    Kicker.use_growl = true
+    Kicker::Growl.use = true
     
-    Growl::Notifier.sharedInstance.expects(:register).with('Kicker', Kicker::GROWL_NOTIFICATIONS.values)
+    Growl::Notifier.sharedInstance.expects(:register).with('Kicker', Kicker::Growl::NOTIFICATIONS.values)
     @kicker.start
   end
   
   it "should _not_ register with growl if growl should not be used" do
     @kicker.stubs(:validate_options!)
-    Kicker.use_growl = false
+    Kicker::Growl.use = false
     
     Growl::Notifier.sharedInstance.expects(:register).never
     @kicker.start