kicker 2.4.0 → 2.5.0

data/test/filesystem_change_test.rb

@@ -1,104 +0,0 @@
-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 return an empty array when a directory doesn't exist while collecting the files in it" do
-    @kicker.send(:files_in_directory, '/does/not/exist').should == []
-  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

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

data/test/fsevents_test.rb

@@ -1,35 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class FakeFSEvent
-  def watch(paths, options={}, &block)
-    @paths = paths
-    @block = block
-  end
-  
-  def run
-  end
-  
-  def fake_event(paths)
-    @block.call(paths)
-  end
-end
-
-describe "Kicker::FSEvents" do
-  it "calls the provided block with changed directories wrapped in an event instance" do
-    events = nil
-    faker = FakeFSEvent.new
-    ::FSEvent.expects(:new).returns(faker)
-    Kicker::FSEvents.start_watching(%w(/path/to/first /path/to/second)) do |events|
-    end
-    paths = %w(/path/to/first)
-    faker.fake_event(paths)
-    events.map { |e| e.path }.should == paths
-  end
-end
-
-describe "Kicker::FSEvents::FSEvent" do
-  it "returns the files from the changed directory ordered by mtime and filename" do
-    fsevent = Kicker::FSEvents::FSEvent.new(File.expand_path('../fixtures', __FILE__))
-    fsevent.files.should == [File.expand_path('../fixtures/a_file_thats_reloaded.rb', __FILE__)]
-  end
-end

data/test/growl_test.rb

@@ -1,87 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-if Kicker::Growl.usable?
-  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
-end

data/test/initialization_test.rb

@@ -1,137 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-module ReloadDotKick; end
-
-describe "Kicker" do
-  before do
-    Kicker.any_instance.stubs(:start)
-  end
-  
-  it "should return the default paths to watch" do
-    Kicker.paths.should == %w{ . }
-  end
-  
-  it "should default the FSEvents latency to 1" do
-    Kicker.latency.should == 1
-  end
-end
-
-describe "Kicker, when initializing" do
-  after do
-    Kicker.paths = %w{ . }
-  end
-  
-  it "should return the extended paths to watch" do
-    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
-    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
-end
-
-describe "Kicker, when starting" do
-  before do
-    Kicker.paths = %w{ /some/file.rb }
-    @kicker = Kicker.new
-    @kicker.stubs(:log)
-    @kicker.startup_chain.stubs(:call)
-    Kicker::FSEvents.stubs(:start_watching)
-  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(:startup_chain).returns(Kicker::CallbackChain.new)
-    Kicker.stubs(:process_chain).returns(Kicker::CallbackChain.new)
-    Kicker.stubs(:pre_process_chain).returns(Kicker::CallbackChain.new)
-    
-    Kicker::Options.stubs(:parser).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!)
-    
-    Kicker.latency = 2.34
-    Kicker::FSEvents.expects(:start_watching).with(['/some'], :latency => 2.34)
-    @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)
-    
-    Kicker::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!)
-    
-    Kicker::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('Kicker::FSEvents')
-    Kicker::FSEvents.stubs(:start_watching).returns(watch_dog)
-    
-    @kicker.expects(:trap).with('INT').yields
-    watch_dog.expects(:stop)
-    @kicker.expects(:exit)
-    
-    @kicker.start
-  end
-  
-  if Kicker::Growl.usable?
-    it "should register with growl if growl should be used" do
-      @kicker.stubs(:validate_options!)
-      Kicker::Growl.use = 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::Growl.use = false
-      
-      Growl::Notifier.sharedInstance.expects(:register).never
-      @kicker.start
-    end
-  end
-  
-  it "should call the startup chain" do
-    @kicker.stubs(:validate_options!)
-    
-    @kicker.startup_chain.expects(:call).with([], false)
-    @kicker.start
-  end
-end

data/test/log_status_helper_test.rb

@@ -1,56 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-describe "Kicker::LogStatus" do
-  yielded = nil
-  
-  before do
-    @status = Kicker::LogStatusHelper.new(proc { |s| yielded = s; 'out' if s.growl? }, 'ls -l')
-  end
-  
-  it "should return whether or not it's for a stdout logger" do
-    @status.call(:stdout)
-    yielded.should.be.stdout
-    yielded.should.not.be.growl
-  end
-  
-  it "should return whether or not it's for a growl logger" do
-    @status.call(:growl)
-    yielded.should.not.be.stdout
-    yielded.should.be.growl
-  end
-  
-  it "should return the command" do
-    @status.call(:growl)
-    yielded.command.should == 'ls -l'
-  end
-  
-  it "should return if it's before executing the command" do
-    @status.call(:growl)
-    yielded.should.be.before
-    yielded.should.be.not.after
-  end
-  
-  it "should return if it's after executing the command" do
-    @status.result('output', true, 0)
-    @status.call(:growl)
-    yielded.should.not.be.before
-    yielded.should.be.after
-  end
-  
-  it "should return the output and status" do
-    @status.result('output', true, 123)
-    @status.call(:growl)
-    yielded.output.should == "output"
-    yielded.should.be.success
-    yielded.exit_code.should.be 123
-  end
-  
-  it "should set the logger type, call the proc with self, and return the output" do
-    @status.call(:growl).should == "out"
-  end
-  
-  it "should not try to call the block if none was given and return nil" do
-    status = Kicker::LogStatusHelper.new(nil, 'ls -l')
-    status.call(:growl).should.be nil
-  end
-end

data/test/options_test.rb

@@ -1,80 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-describe "Kicker::Options.parse" do
-  after do
-    Kicker.latency = 1
-    Kicker.paths = %w{ . }
-    Kicker.silent = false
-    Kicker.quiet = false
-    Kicker::Growl.use = true
-    Kicker::Growl.command = nil
-  end
-  
-  it "should parse the paths" do
-    Kicker::Options.parse([])
-    Kicker.paths.should == %w{ . }
-    
-    Kicker::Options.parse(%w{ /some/file.rb })
-    Kicker.paths.should == %w{ /some/file.rb }
-    
-    Kicker::Options.parse(%w{ /some/file.rb /a/dir /and/some/other/file.rb })
-    Kicker.paths.should == %w{ /some/file.rb /a/dir /and/some/other/file.rb }
-  end
-  
-  if Kicker::Growl.usable?
-    it "should parse if growl shouldn't be used" do
-      Kicker::Options.parse([])
-      Kicker::Growl.should.use
-    
-      Kicker::Options.parse(%w{ --no-growl })
-      Kicker::Growl.should.not.use
-    end
-  end
-  
-  it "should parse if we should keep output to a minimum" do
-    Kicker::Options.parse([])
-    Kicker.should.not.be.silent
-    
-    Kicker::Options.parse(%w{ -s })
-    Kicker.should.be.silent
-  end
-  
-  it 'should parse whether or not to run in quiet mode and enable silent mode if quiet' do
-    Kicker::Options.parse([])
-    Kicker.should.not.be.quiet
-    Kicker.should.not.be.silent
-    
-    Kicker::Options.parse(%w{ --quiet })
-    Kicker.should.be.quiet
-    Kicker.should.be.silent
-  end
-  
-  it "should parse whether or not to clear the console before running" do
-    Kicker::Options.parse([])
-    Kicker.should.not.clear_console
-
-    Kicker::Options.parse(%w{ --clear })
-    Kicker.should.clear_console
-  end
-  
-  if Kicker::Growl.usable?
-    it "should parse the Growl command to use when the user clicks the Growl succeeded message" do
-      Kicker::Options.parse(%w{ --growl-command ls })
-      Kicker::Growl.command.should == 'ls'
-    end
-  end
-  
-  it "should parse the latency to pass to FSEvents" do
-    Kicker::Options.parse(%w{ -l 2.5 })
-    Kicker.latency.should == 2.5
-    
-    Kicker::Options.parse(%w{ --latency 3.5 })
-    Kicker.latency.should == 3.5
-  end
-  
-  it "should parse recipe requires" do
-    Kicker::Recipes.expects(:recipe).with('rails')
-    Kicker::Recipes.expects(:recipe).with('jstest')
-    Kicker::Options.parse(%w{ -r rails --recipe jstest })
-  end
-end