kicker 2.0.0

data/test/core_ext_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Array#take_and_map" do
+  before do
+    @array = %w{ 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 }
+  end
+  
+  it "should return a new array of the return values of each block call that evaluates to true" do
+    @array.take_and_map { |x| $1 if x =~ /^ba(\w)/ }.should == %w{ r z }
+  end
+  
+  it "should flatten and compact the result array" do
+    @array.take_and_map do |x|
+      x =~ /^ba/ ? %w{ f o o } : [nil]
+    end.should == %w{ f o o f o o }
+  end
+  
+  it "should not flatten and compact the result array if specified" do
+    @array.take_and_map(false) do |x|
+      x =~ /^ba/ ? %w{ f o o } : [nil]
+    end.should == [[nil], %w{ f o o }, %w{ f o o }]
+  end
+end

data/test/filesystem_change_test.rb

@@ -0,0 +1,100 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Kicker, when a change occurs" do
+  before do
+    remove_tmp_files!
+    
+    Kicker.any_instance.stubs(:last_command_succeeded?).returns(true)
+    Kicker.any_instance.stubs(:log)
+    @kicker = Kicker.new({})
+  end
+  
+  it "should store the current time as when the last change occurred" do
+    now = Time.now
+    Time.stubs(:now).returns(now)
+    
+    @kicker.send(:finished_processing!)
+    @kicker.last_event_processed_at.should.be now
+  end
+  
+  it "should return an array of files that have changed since the last event" do
+    file1 = touch('1')
+    file2 = touch('2')
+    file3 = touch('3')
+    file4 = touch('4')
+    @kicker.send(:finished_processing!)
+    
+    events = [event(file1, file2), event(file3, file4)]
+    
+    @kicker.send(:changed_files, events).should == []
+    @kicker.send(:finished_processing!)
+    
+    sleep(1)
+    touch('2')
+    
+    @kicker.send(:changed_files, events).should == [file2]
+    @kicker.send(:finished_processing!)
+    
+    sleep(1)
+    touch('1')
+    touch('3')
+    
+    @kicker.send(:changed_files, events).should == [file1, file3]
+  end
+  
+  it "should not break when determining changed files from events with missing files" do
+    file1 = touch('1')
+    file2 = touch('2')
+    @kicker.send(:finished_processing!)
+    sleep(1)
+    touch('2')
+    
+    events = [event(file1, file2), event('/does/not/exist')]
+    @kicker.send(:changed_files, events).should == [file2]
+  end
+  
+  it "should return relative file paths if the path is relative to the current work dir" do
+    sleep(1)
+    file = touch('1')
+    
+    Dir.stubs(:pwd).returns('/tmp')
+    @kicker.send(:changed_files, [event(file)]).should == [File.basename(file)]
+  end
+  
+  it "should call the full_chain with all changed files" do
+    files = %w{ /file/1 /file/2 }
+    events = [event('/file/1'), event('/file/2')]
+    
+    @kicker.expects(:changed_files).with(events).returns(files)
+    @kicker.full_chain.expects(:call).with(files)
+    @kicker.expects(:finished_processing!)
+    
+    @kicker.send(:process, events)
+  end
+  
+  it "should not call the full_chain if there were no changed files" do
+    @kicker.stubs(:changed_files).returns([])
+    @kicker.full_chain.expects(:call).never
+    @kicker.expects(:finished_processing!).never
+    
+    @kicker.send(:process, [event()])
+  end
+  
+  private
+  
+  def touch(file)
+    file = "/tmp/kicker_test_tmp_#{file}"
+    `touch #{file}`
+    file
+  end
+  
+  def event(*files)
+    event = stub('FSEvent')
+    event.stubs(:path).returns('/tmp')
+    event
+  end
+  
+  def remove_tmp_files!
+    Dir.glob("/tmp/kicker_test_tmp_*").each { |f| File.delete(f) }
+  end
+end

data/test/fixtures/a_file_thats_reloaded.rb

@@ -0,0 +1,2 @@
+$FROM_RELOADED_FILE ||= 0
+$FROM_RELOADED_FILE += 1

data/test/initialization_test.rb

@@ -0,0 +1,165 @@
+require File.expand_path('../test_helper', __FILE__)
+
+module ReloadDotKick; end
+
+describe "Kicker" do
+  before 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
+  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 })
+  end
+  
+  it "should return the extended paths to watch" do
+    @kicker.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
+  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
+  end
+end
+
+describe "Kicker, when starting" do
+  before do
+    @kicker = Kicker.new(:paths => %w{ /some/file.rb })
+    @kicker.stubs(:log)
+    Rucola::FSEvents.stubs(:start_watching)
+    OSX.stubs(:CFRunLoopRun)
+  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::OPTION_PARSER_CALLBACK.stubs(:call).returns(mock('OptionParser', :help => 'help'))
+    @kicker.expects(:puts).with("help")
+    @kicker.expects(:exit)
+    
+    @kicker.start
+  end
+  
+  it "should warn the user and exit if any of the given paths doesn't exist" do
+    @kicker.stubs(:validate_paths_and_command!)
+    
+    @kicker.expects(:puts).with("The given path `/some/file.rb' does not exist")
+    @kicker.expects(:exit).with(1)
+    
+    @kicker.start
+  end
+  
+  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.start
+  end
+  
+  it "should start a FSEvents stream which watches all paths, but the dirnames of paths if they're files" do
+    @kicker.stubs(:validate_options!)
+    File.stubs(:directory?).with('/some/file.rb').returns(false)
+    
+    Rucola::FSEvents.expects(:start_watching).with(['/some'], :latency => @kicker.latency)
+    @kicker.start
+  end
+  
+  it "should start a FSEvents stream with a block which calls #process with any generated events" do
+    @kicker.stubs(:validate_options!)
+    
+    Rucola::FSEvents.expects(:start_watching).yields(['event'])
+    @kicker.expects(:process).with(['event'])
+    
+    @kicker.start
+  end
+  
+  it "should setup a signal handler for `INT' which stops the FSEvents stream and exits" do
+    @kicker.stubs(:validate_options!)
+    
+    watch_dog = stub('Rucola::FSEvents')
+    Rucola::FSEvents.stubs(:start_watching).returns(watch_dog)
+    
+    @kicker.expects(:trap).with('INT').yields
+    watch_dog.expects(:stop)
+    @kicker.expects(:exit)
+    
+    @kicker.start
+  end
+  
+  it "should start a CFRunLoop" do
+    @kicker.stubs(:validate_options!)
+    
+    OSX.expects(:CFRunLoopRun)
+    @kicker.start
+  end
+  
+  it "should register with growl if growl should be used" do
+    @kicker.stubs(:validate_options!)
+    Kicker.use_growl = true
+    
+    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
+    
+    Growl::Notifier.sharedInstance.expects(:register).never
+    @kicker.start
+  end
+end

data/test/options_test.rb

@@ -0,0 +1,30 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Kicker.parse_options" do
+  it "should parse the paths" do
+    Kicker.parse_options([])[:paths].should.be nil
+    
+    Kicker.parse_options(%w{ /some/file.rb })[:paths].should == %w{ /some/file.rb }
+    Kicker.parse_options(%w{ /some/file.rb /a/dir /and/some/other/file.rb })[:paths].should ==
+      %w{ /some/file.rb /a/dir /and/some/other/file.rb }
+  end
+  
+  it "should parse if growl shouldn't be used" do
+    Kicker.parse_options([])[:growl].should == true
+    Kicker.parse_options(%w{ --no-growl })[:growl].should == false
+  end
+  
+  it "should parse the Growl command to use when the user clicks the Growl succeeded message" do
+    Kicker.parse_options(%w{ --growl-command ls })[:growl_command].should == 'ls'
+  end
+  
+  it "should parse the latency to pass to FSEvents" do
+    Kicker.parse_options(%w{ -l 2.5 })[:latency].should == 2.5
+    Kicker.parse_options(%w{ --latency 3.5 })[:latency].should == 3.5
+  end
+  
+  it "should parse recipe requires" do
+    Kicker.parse_options(%w{ -r rails -r jstest })[:recipes].should == %w{ rails jstest }
+    Kicker.parse_options(%w{ --recipe rails --recipe jstest })[:recipes].should == %w{ rails jstest }
+  end
+end

data/test/recipes/could_not_handle_file_test.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe "Kicker, concerning the default `could not handle file' callback" do
+  it "should log that it could not handle the given files" do
+    Kicker::Utils.expects(:log).with('')
+    Kicker::Utils.expects(:log).with("Could not handle: /file/1, /file/2")
+    Kicker::Utils.expects(:log).with('')
+    
+    Kicker.post_process_chain.last.call(%w{ /file/1 /file/2 })
+  end
+end

data/test/recipes/dot_kick_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+before = Kicker.process_chain.dup
+require 'kicker/recipes/dot_kick'
+DOT_KICK = (Kicker.process_chain - before).first
+
+describe "The .kick handler" do
+  it "should reset $LOADED_FEATURES and callback chains to state before loading .kick and reload .kick" do
+    ReloadDotKick.save_state
+    
+    features_before_dot_kick = $LOADED_FEATURES.dup
+    chains_before_dot_kick = Kicker.full_chain.map { |c| c.dup }
+    
+    ReloadDotKick.expects(:load).with('.kick').twice
+    
+    2.times do
+      require File.expand_path('../../fixtures/a_file_thats_reloaded', __FILE__)
+      process {}
+      DOT_KICK.call(%w{ .kick })
+    end
+    
+    $FROM_RELOADED_FILE.should == 2
+    $LOADED_FEATURES.should == features_before_dot_kick
+    Kicker.full_chain.should == chains_before_dot_kick
+  end
+end

data/test/recipes/execute_cli_command_test.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+describe "Kicker, concerning the `execute a command-line' callback" do
+  it "should parse the command and add the callback" do
+    before = Kicker.pre_process_chain.length
+    
+    Kicker.parse_options(%w{ -e ls })
+    Kicker.pre_process_chain.length.should == before + 1
+    
+    Kicker.parse_options(%w{ --execute ls })
+    Kicker.pre_process_chain.length.should == before + 2
+  end
+  
+  it "should call execute with the given command" do
+    Kicker.parse_options(%w{ -e ls })
+    
+    callback = Kicker.pre_process_chain.last
+    callback.should.be.instance_of Proc
+    
+    Kicker::Utils.expects(:execute).with('sh -c "ls"')
+    
+    callback.call(%w{ /file/1 /file/2 }).should.not.be.instance_of Array
+  end
+  
+  it "should clear the files array to halt the chain" do
+    Kicker::Utils.stubs(:execute)
+    
+    files = %w{ /file/1 /file/2 }
+    Kicker.pre_process_chain.last.call(files)
+    files.should.be.empty
+  end
+end

data/test/recipes/ignore_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+before = Kicker.pre_process_chain.dup
+require 'kicker/recipes/ignore'
+IGNORE = (Kicker.pre_process_chain - before).first
+
+describe "The Ignore handler" do
+  it "should remove files that match the given regexp" do
+    ignore(/^fo{2}bar/)
+    
+    files = %w{ Rakefile foobar foobarbaz }
+    IGNORE.call(files)
+    files.should == %w{ Rakefile }
+  end
+  
+  it "should remove files that match the given string" do
+    ignore('bazbla')
+    
+    files = %w{ Rakefile bazbla bazblabla }
+    IGNORE.call(files)
+    files.should == %w{ Rakefile bazblabla }
+  end
+  
+  it "should ignore a few file types by default" do
+    files = %w{ Rakefile foo/bar/dev.log .svn/foo svn-commit.tmp .git/foo tmp }
+    IGNORE.call(files)
+    files.should == %w{ Rakefile }
+  end
+end

data/test/recipes/jstest_test.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+before = Kicker.process_chain.dup
+require 'kicker/recipes/jstest'
+JSTEST = (Kicker.process_chain - before).first
+
+describe "The HeadlessSquirrel handler" do
+  before do
+    @files = %w{ Rakefile }
+  end
+  
+  it "should match any test case files" do
+    @files += %w{ test/javascripts/ui_test.html test/javascripts/admin_test.js }
+    
+    Kicker::Utils.expects(:execute).
+      with("jstest test/javascripts/ui_test.html test/javascripts/admin_test.html")
+    
+    JSTEST.call(@files)
+    @files.should == %w{ Rakefile }
+  end
+  
+  it "should map public/javascripts libs to test/javascripts" do
+    @files += %w{ public/javascripts/ui.js public/javascripts/admin.js }
+    
+    Kicker::Utils.expects(:execute).
+      with("jstest test/javascripts/ui_test.html test/javascripts/admin_test.html")
+    
+    JSTEST.call(@files)
+    @files.should == %w{ Rakefile }
+  end
+end