alloy-kicker 1.1.2 → 1.9.0

data/README.rdoc

@@ -35,4 +35,19 @@ And for fun, ghetto-autotest:
 
 == Installation
 
-  $ sudo gem install alloy-kicker -s http://gems.github.com
+  $ sudo gem install alloy-kicker -s http://gems.github.com
+
+== TODO
+
+  15:12 sandbags: ideally i would like all events within a small window (e.g. 2s) to be batched into one
+  15:12 sandbags: depending upon whether what is being reported is "file X changed" or "some files in directory X" changed
+  15:12 sandbags: i forget the granularity FSEvents supports
+  15:13 alloy: Yeah the window can be changed, which is a good idea
+  15:13 alloy: FSEvents simply reports changes to files in dir X. nothing more
+  15:14 sandbags: btw.. what is your rationale for using "!" in method names?
+  15:14 alloy: So in this case we should simply keep the time at which an event occurs and then grep the dirs for files with an higher mtime
+  15:14 sandbags: works for me
+  15:16 alloy: Well the rationale in these cases was either it could raise something (validate) or it would run something external. But really it was just for kicks :)
+  15:16 alloy: It could be cleaned up, as I agree it doesn't help much
+  15:17 sandbags: i think it would be easy to grok without them
+  15:17 alloy: Yeah indeed

data/Rakefile

@@ -22,7 +22,7 @@ end
 
 Rake::TestTask.new do |t|
   t.libs << "test"
-  t.test_files = FileList['test/*_test.rb']
+  t.test_files = FileList['test/**/*_test.rb']
   t.options = '-rs'
 end
 

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 1
-:minor: 1
-:patch: 2
+:minor: 9
+:patch: 0

data/bin/kicker

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 
 require File.expand_path('../../lib/kicker', __FILE__)
-Kicker.run!
+Kicker.run

data/lib/kicker.rb

@@ -1,65 +1,53 @@
 $:.unshift File.expand_path('../../vendor', __FILE__)
 require 'rucola/fsevents'
-require 'growlnotifier/growl_helpers'
-require 'optparse'
+
+require 'kicker/callback_chain'
+require 'kicker/growl'
+require 'kicker/options'
+require 'kicker/utils'
+require 'kicker/validate'
+
+require 'kicker/recipes/could_not_handle_file'
+require 'kicker/recipes/execute_cli_command'
 
 class Kicker
-  OPTION_PARSER = lambda do |options|
-    OptionParser.new do |opts|
-      opts.banner = "Usage: #{$0} [options] -e [command] [paths to watch]"
-      
-      opts.on('-e', '--execute [COMMAND]', 'The command to execute.') do |command|
-        options[:command] = command
-      end
-      
-      opts.on('--[no-]growl', 'Whether or not to use Growl. Default is to use growl.') do |growl|
-        options[:growl] = growl
-      end
-      
-      opts.on('--growl-command [COMMAND]', 'The command to execute when the Growl succeeded message is clicked.') do |command|
-        options[:growl_command] = command
-      end
+  class << self
+    attr_accessor :latency
+    
+    def latency
+      @latency ||= 1.5
+    end
+    
+    def paths
+      @paths ||= %w{ . }
+    end
+    
+    def run(argv = ARGV)
+      load '.kick' if File.exist?('.kick')
+      new(parse_options(argv)).start
     end
   end
   
-  def self.parse_options(argv)
-    argv = argv.dup
-    options = { :growl => true }
-    OPTION_PARSER.call(options).parse!(argv)
-    options[:paths] = argv
-    options
-  end
-  
-  def self.run!(argv = ARGV)
-    new(parse_options(argv)).start
-  end
-  
-  include Growl
-  GROWL_NOTIFICATIONS = {
-    :change => 'Change occured',
-    :succeeded => 'Command succeeded',
-    :failed => 'Command failed'
-  }
-  GROWL_DEFAULT_CALLBACK = lambda do
-    OSX::NSWorkspace.sharedWorkspace.launchApplication('Terminal')
-  end
-  
-  attr_writer :command
-  attr_reader :paths
-  attr_accessor :use_growl, :growl_command
+  attr_reader :latency, :paths, :last_event_processed_at
   
   def initialize(options)
-    @paths         = options[:paths].map { |path| File.expand_path(path) }
-    @command       = options[:command]
+    @paths = (options[:paths] ? options[:paths] : Kicker.paths).map { |path| File.expand_path(path) }
+    
+    @latency       = options[:latency] || self.class.latency
     @use_growl     = options[:growl]
     @growl_command = options[:growl_command]
+    
+    finished_processing!
+  end
+  
+  def callback_chain
+    self.class.callback_chain
   end
   
   def start
     validate_options!
     
     log "Watching for changes on: #{@paths.join(', ')}"
-    log "With command: #{command}"
     log ''
     
     run_watch_dog!
@@ -68,52 +56,11 @@ class Kicker
     OSX.CFRunLoopRun
   end
   
-  def command
-    "sh -c #{@command.inspect}"
-  end
-  
   private
   
-  def validate_options!
-    validate_paths_and_command!
-    validate_paths_exist!
-  end
-  
-  def validate_paths_and_command!
-    if @paths.empty? && @command.nil?
-      puts OPTION_PARSER.call(nil).help
-      exit
-    end
-  end
-  
-  def validate_paths_exist!
-    @paths.each do |path|
-      unless File.exist?(path)
-        puts "The given path `#{path}' does not exist"
-        exit 1
-      end
-    end
-  end
-  
-  def log(message)
-    puts "[#{Time.now}] #{message}"
-  end
-  
-  def last_command_succeeded?
-    $?.success?
-  end
-  
-  def last_command_status
-    $?.to_i
-  end
-  
-  def start_growl!
-    Growl::Notifier.sharedInstance.register('Kicker', Kicker::GROWL_NOTIFICATIONS.values)
-  end
-  
   def run_watch_dog!
     dirs = @paths.map { |path| File.directory?(path) ? path : File.dirname(path) }
-    watch_dog = Rucola::FSEvents.start_watching(*dirs) { |events| process(events) }
+    watch_dog = Rucola::FSEvents.start_watching(dirs, :latency => @latency) { |events| process(events) }
     
     trap('INT') do
       log "Cleaning up…"
@@ -122,30 +69,20 @@ class Kicker
     end
   end
   
-  def process(events)
-    events.each do |event|
-      @paths.each do |path|
-        return execute! if event.last_modified_file =~ /^#{path}/
-      end
-    end
+  def finished_processing!
+    @last_event_processed_at = Time.now
   end
   
-  def execute!
-    log "Change occured. Executing command:"
-    growl(GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command') if @use_growl
-    
-    output = `#{command}`
-    output.strip.split("\n").each { |line| log "  #{line}" }
-    
-    log "Command #{last_command_succeeded? ? 'succeeded' : "failed (#{last_command_status})"}"
-    
-    if @use_growl
-      if last_command_succeeded?
-        callback = @growl_command.nil? ? GROWL_DEFAULT_CALLBACK : lambda { system(@growl_command) }
-        growl(GROWL_NOTIFICATIONS[:succeeded], "Kicker: Command succeeded", output, &callback)
-      else
-        growl(GROWL_NOTIFICATIONS[:failed], "Kicker: Command failed (#{last_command_status})", output, &GROWL_DEFAULT_CALLBACK)
-      end
+  def changed_files(events)
+    events.map do |event|
+      event.files.select { |file| File.mtime(file) > @last_event_processed_at }
+    end.flatten
+  end
+  
+  def process(events)
+    unless (files = changed_files(events)).empty?
+      callback_chain.run(self, files)
+      finished_processing!
     end
   end
 end

data/lib/kicker/callback_chain.rb

@@ -0,0 +1,21 @@
+class Kicker
+  class CallbackChain < Array
+    alias_method :append_callback,  :push
+    alias_method :prepend_callback, :unshift
+    
+    def run(kicker, files)
+      each do |callback|
+        files = callback.call(kicker, files)
+        break if !files.is_a?(Array) || files.empty?
+      end
+    end
+  end
+  
+  def self.callback_chain
+    @callback_chain ||= CallbackChain.new
+  end
+  
+  def self.callback=(callback)
+    callback_chain.prepend_callback(callback)
+  end
+end

data/lib/kicker/growl.rb

@@ -0,0 +1,23 @@
+require 'growlnotifier/growl_helpers'
+
+class Kicker
+  include Growl
+  
+  attr_accessor :use_growl, :growl_command
+  
+  GROWL_NOTIFICATIONS = {
+    :change => 'Change occured',
+    :succeeded => 'Command succeeded',
+    :failed => 'Command failed'
+  }
+  
+  GROWL_DEFAULT_CALLBACK = lambda do
+    OSX::NSWorkspace.sharedWorkspace.launchApplication('Terminal')
+  end
+  
+  private
+  
+  def start_growl!
+    Growl::Notifier.sharedInstance.register('Kicker', Kicker::GROWL_NOTIFICATIONS.values)
+  end
+end

data/lib/kicker/options.rb

@@ -0,0 +1,33 @@
+require 'optparse'
+
+class Kicker
+  def self.option_parser
+    @option_parser ||= OptionParser.new do |opt|
+      opt.banner = "Usage: #{$0} [options] [paths to watch]"
+    end
+  end
+  
+  OPTION_PARSER_CALLBACK = lambda do |options|
+    option_parser.on('--[no-]growl', 'Whether or not to use Growl. Default is to use growl.') do |growl|
+      options[:growl] = growl
+    end
+    
+    option_parser.on('--growl-command [COMMAND]', 'The command to execute when the Growl succeeded message is clicked.') do |command|
+      options[:growl_command] = command
+    end
+    
+    option_parser.on('-l', '--latency [FLOAT]', 'FSEvent grouping latency') do |latency|
+      options[:latency] = Float(latency)
+    end
+    
+    option_parser
+  end
+  
+  def self.parse_options(argv)
+    argv = argv.dup
+    options = { :growl => true }
+    OPTION_PARSER_CALLBACK.call(options).parse!(argv)
+    options[:paths] = argv unless argv.empty?
+    options
+  end
+end

data/lib/kicker/recipes/could_not_handle_file.rb

@@ -0,0 +1,7 @@
+class Kicker
+  COULD_NOT_HANDLE_CALLBACK = lambda do |kicker, files|
+    kicker.log("Could not handle: #{files.join(', ')}")
+  end
+  
+  self.callback = COULD_NOT_HANDLE_CALLBACK
+end

data/lib/kicker/recipes/execute_cli_command.rb

@@ -0,0 +1,7 @@
+class Kicker
+  option_parser.on('-e', '--execute [COMMAND]', 'The command to execute.') do |command|
+    Kicker.callback = lambda do |kicker, _|
+      kicker.execute_command "sh -c #{command.inspect}"
+    end
+  end
+end

data/lib/kicker/utils.rb

@@ -0,0 +1,34 @@
+class Kicker
+  def execute_command(command)
+    log "Change occured. Executing command:"
+    growl(GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command') if @use_growl
+    
+    output = `#{command}`
+    output.strip.split("\n").each { |line| log "  #{line}" }
+    
+    log "Command #{last_command_succeeded? ? 'succeeded' : "failed (#{last_command_status})"}"
+    
+    if @use_growl
+      if last_command_succeeded?
+        callback = @growl_command.nil? ? GROWL_DEFAULT_CALLBACK : lambda { system(@growl_command) }
+        growl(GROWL_NOTIFICATIONS[:succeeded], "Kicker: Command succeeded", output, &callback)
+      else
+        growl(GROWL_NOTIFICATIONS[:failed], "Kicker: Command failed (#{last_command_status})", output, &GROWL_DEFAULT_CALLBACK)
+      end
+    end
+  end
+  
+  def log(message)
+    puts "[#{Time.now}] #{message}"
+  end
+  
+  private
+  
+  def last_command_succeeded?
+    $?.success?
+  end
+  
+  def last_command_status
+    $?.to_i
+  end
+end

data/lib/kicker/validate.rb

@@ -0,0 +1,24 @@
+class Kicker
+  private
+  
+  def validate_options!
+    validate_paths_and_command!
+    validate_paths_exist!
+  end
+  
+  def validate_paths_and_command!
+    if callback_chain.length == 1
+      puts OPTION_PARSER_CALLBACK.call(nil).help
+      exit
+    end
+  end
+  
+  def validate_paths_exist!
+    @paths.each do |path|
+      unless File.exist?(path)
+        puts "The given path `#{path}' does not exist"
+        exit 1
+      end
+    end
+  end
+end

data/test/callback_chain_test.rb

@@ -0,0 +1,103 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Kicker, concerning its callback chain" do
+  it "should return the callback chain instance" do
+    Kicker.callback_chain.should.be.instance_of Kicker::CallbackChain
+  end
+  
+  it "should provide a shortcut method which prepends a callback" do
+    Kicker.callback = lambda { :from_callback }
+    Kicker.callback_chain.first.call.should == :from_callback
+  end
+  
+  it "should be accessible by an instance" do
+    kicker = Kicker.new({})
+    kicker.callback_chain.should.be Kicker.callback_chain
+  end
+end
+
+describe "Kicker::CallbackChain" do
+  it "should be a subclass of Array" do
+    Kicker::CallbackChain.superclass.should.be Array
+  end
+end
+
+describe "An instance of Kicker::CallbackChain, concerning it's API" do
+  before do
+    @chain = Kicker::CallbackChain.new
+    
+    @callback1 = lambda {}
+    @callback2 = lambda {}
+  end
+  
+  it "should append a callback" do
+    @chain << @callback1
+    @chain.append_callback(@callback2)
+    
+    @chain.should == [@callback1, @callback2]
+  end
+  
+  it "should prepend a callback" do
+    @chain << @callback1
+    @chain.prepend_callback(@callback2)
+    
+    @chain.should == [@callback2, @callback1]
+  end
+end
+
+describe "An instance of Kicker::CallbackChain, when running the chain" do
+  before do
+    @kicker = Kicker.new({})
+    
+    @chain = Kicker::CallbackChain.new
+    @result = []
+  end
+  
+  it "should call the callbacks from first to last" do
+    @chain.append_callback lambda { @result << 1 }
+    @chain.append_callback lambda { @result << 2 }
+    @chain.run(@kicker, [])
+    @result.should == [1, 2]
+  end
+  
+  it "should pass in the Kicker instance with each yield" do
+    kicker = nil
+    @chain.append_callback lambda { |x, _| kicker = x }
+    @chain.run(@kicker, [])
+    kicker.should.be @kicker
+  end
+  
+  it "should pass the files array given to run to the first callback and pass the result array of that call to the next callback and so on" do
+    @chain.append_callback lambda { |_, files|
+      @result.concat(files)
+      %w{ /file/3 /file/4 }
+    }
+    
+    @chain.append_callback lambda { |_, files|
+      @result.concat(files)
+      []
+    }
+    
+    @chain.run(@kicker, %w{ /file/1 /file/2 })
+    @result.should == %w{ /file/1 /file/2 /file/3 /file/4 }
+  end
+  
+  it "should halt the callback chain once an empty array is returned from a callback" do
+    @chain.append_callback lambda { @result << 1; [] }
+    @chain.append_callback lambda { @result << 2 }
+    @chain.run(@kicker, %w{ /file/1 /file/2 })
+    @result.should == [1]
+  end
+  
+  it "should halt the callback chain if not an Array instance is returned from a callback" do
+    [nil, false, ''].each do |object|
+      @chain.clear
+      @result.clear
+      
+      @chain.append_callback lambda { @result << 1; object }
+      @chain.append_callback lambda { @result << 2 }
+      @chain.run(@kicker, %w{ /file/1 /file/2 })
+      @result.should == [1]
+    end
+  end
+end

data/test/filesystem_change_test.rb

@@ -0,0 +1,75 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Kicker, when a change occurs" do
+  before do
+    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 run the callback 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.callback_chain.expects(:run).with(@kicker, files)
+    @kicker.expects(:finished_processing!)
+    
+    @kicker.send(:process, events)
+  end
+  
+  it "should not run the callback chain if there were no changed files" do
+    @kicker.stubs(:changed_files).returns([])
+    @kicker.callback_chain.expects(:run).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(:files).returns(files)
+    event
+  end
+end

data/test/initialization_test.rb

@@ -0,0 +1,133 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Kicker" do
+  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 before running" do
+    Kicker.any_instance.stubs(:start)
+    
+    File.expects(:exist?).with('.kick').returns(true)
+    Kicker.expects(:load).with('.kick')
+    Kicker.run
+  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.5
+  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 is no extra callback defined" do
+    @kicker.stubs(:validate_paths_exist!)
+    Kicker.stubs(:callback_chain).returns([1])
+    
+    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,25 @@
+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
+end

data/test/recipes/could_not_handle_file_test.rb

@@ -0,0 +1,9 @@
+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 = Kicker.new({})
+    kicker.expects(:log).with("Could not handle: /file/1, /file/2")
+    Kicker.callback_chain.last.call(kicker, %w{ /file/1 /file/2 })
+  end
+end

data/test/recipes/execute_cli_command_test.rb

@@ -0,0 +1,25 @@
+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.callback_chain.length
+    
+    Kicker.parse_options(%w{ -e ls })
+    Kicker.callback_chain.length.should == before + 1
+    
+    Kicker.parse_options(%w{ --execute ls })
+    Kicker.callback_chain.length.should == before + 2
+  end
+  
+  it "should call execute_command with the given command" do
+    Kicker.parse_options(%w{ -e ls })
+    
+    callback = Kicker.callback_chain.first
+    callback.should.be.instance_of Proc
+    
+    kicker = Kicker.new({})
+    kicker.expects(:execute_command).with('sh -c "ls"')
+    
+    callback.call(kicker, %w{ /file/1 /file/2 }).should.not.be.instance_of Array
+  end
+end

data/test/utils_test.rb

@@ -0,0 +1,74 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "A Kicker instance, concerning its utility methods" do
+  before do
+    Kicker.any_instance.stubs(:last_command_succeeded?).returns(true)
+    @kicker = Kicker.new(:paths => %w{ /some/dir }, :command => 'ls -l')
+  end
+  
+  it "should print a log entry with timestamp" do
+    now = Time.now
+    Time.stubs(:now).returns(now)
+    
+    @kicker.expects(:puts).with("[#{now}] the message")
+    @kicker.send(:log, 'the message')
+  end
+  
+  it "should log the output of the command indented by 2 spaces and whether or not the command succeeded" do
+    @kicker.stubs(:`).returns("line 1\nline 2")
+    
+    @kicker.expects(:log).with('Change occured. Executing command:')
+    @kicker.expects(:log).with('  line 1')
+    @kicker.expects(:log).with('  line 2')
+    @kicker.expects(:log).with('Command succeeded')
+    @kicker.execute_command('')
+    
+    @kicker.stubs(:last_command_succeeded?).returns(false)
+    @kicker.stubs(:last_command_status).returns(123)
+    @kicker.expects(:log).with('Change occured. Executing command:')
+    @kicker.expects(:log).with('  line 1')
+    @kicker.expects(:log).with('  line 2')
+    @kicker.expects(:log).with('Command failed (123)')
+    @kicker.execute_command('')
+  end
+  
+  it "should send the Growl messages with the default click callback" do
+    @kicker.stubs(:log)
+    
+    @kicker.stubs(:`).returns("line 1\nline 2")
+    @kicker.use_growl = true
+    
+    OSX::NSWorkspace.sharedWorkspace.expects(:launchApplication).with('Terminal').times(2)
+    
+    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command')
+    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:succeeded], 'Kicker: Command succeeded', "line 1\nline 2").yields
+    @kicker.execute_command('')
+    
+    @kicker.stubs(:last_command_succeeded?).returns(false)
+    @kicker.stubs(:last_command_status).returns(123)
+    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command')
+    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:failed], 'Kicker: Command failed (123)', "line 1\nline 2").yields
+    @kicker.execute_command('')
+  end
+  
+  it "should send the Growl messages with a click callback which executes the specified growl command when succeeded" do
+    @kicker.stubs(:log)
+    
+    @kicker.stubs(:`).returns("line 1\nline 2")
+    @kicker.use_growl = true
+    @kicker.growl_command = 'ls -l'
+    
+    @kicker.expects(:system).with('ls -l').times(1)
+    OSX::NSWorkspace.sharedWorkspace.expects(:launchApplication).with('Terminal').times(1)
+    
+    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command')
+    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:succeeded], 'Kicker: Command succeeded', "line 1\nline 2").yields
+    @kicker.execute_command('')
+    
+    @kicker.stubs(:last_command_succeeded?).returns(false)
+    @kicker.stubs(:last_command_status).returns(123)
+    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command')
+    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:failed], 'Kicker: Command failed (123)', "line 1\nline 2").yields
+    @kicker.execute_command('')
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: alloy-kicker
 version: !ruby/object:Gem::Version 
-  version: 1.1.2
+  version: 1.9.0
 platform: ruby
 authors: 
 - Eloy Duran
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-08 00:00:00 -07:00
+date: 2009-06-25 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -30,8 +30,21 @@ files:
 - VERSION.yml
 - bin/kicker
 - lib/kicker.rb
-- test/kicker_test.rb
+- lib/kicker/callback_chain.rb
+- lib/kicker/growl.rb
+- lib/kicker/options.rb
+- lib/kicker/recipes/could_not_handle_file.rb
+- lib/kicker/recipes/execute_cli_command.rb
+- lib/kicker/utils.rb
+- lib/kicker/validate.rb
+- test/callback_chain_test.rb
+- test/filesystem_change_test.rb
+- test/initialization_test.rb
+- test/options_test.rb
+- test/recipes/could_not_handle_file_test.rb
+- test/recipes/execute_cli_command_test.rb
 - test/test_helper.rb
+- test/utils_test.rb
 - vendor/growlnotifier/growl.rb
 - vendor/growlnotifier/growl_helpers.rb
 - vendor/rucola/fsevents.rb
@@ -63,5 +76,11 @@ signing_key:
 specification_version: 2
 summary: A simple OS X CLI tool which uses FSEvents to run a given shell command.
 test_files: 
-- test/kicker_test.rb
+- test/callback_chain_test.rb
+- test/filesystem_change_test.rb
+- test/initialization_test.rb
+- test/options_test.rb
+- test/recipes/could_not_handle_file_test.rb
+- test/recipes/execute_cli_command_test.rb
 - test/test_helper.rb
+- test/utils_test.rb

data/test/kicker_test.rb

@@ -1,221 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-describe "Kicker.parse_options" do
-  it "should parse the paths" do
-    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 the command" do
-    Kicker.parse_options(%w{ -e ls })[:command].should == 'ls'
-    Kicker.parse_options(%w{ --execute ls })[:command].should == 'ls'
-  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
-end
-
-describe "Kicker, when initializing" do
-  before do
-    @kicker = Kicker.new(:paths => %w{ /some/dir a/relative/path }, :command => 'ls -l')
-  end
-  
-  it "should return the extended paths to watch" do
-    @kicker.paths.should == ['/some/dir', File.expand_path('a/relative/path')]
-  end
-  
-  it "should return the command to execute once a change occurs" do
-    @kicker.command.should == 'sh -c "ls -l"'
-  end
-end
-
-describe "Kicker, when starting" do
-  before do
-    @kicker = Kicker.new(:paths => %w{ /some/file.rb }, :command => 'ls -l')
-    @kicker.stubs(:log)
-    Rucola::FSEvents.stubs(:start_watching)
-    OSX.stubs(:CFRunLoopRun)
-  end
-  
-  it "should show the usage banner and exit when there are no paths and a command" do
-    @kicker.instance_variable_set("@paths", [])
-    @kicker.command = nil
-    @kicker.stubs(:validate_paths_exist!)
-    
-    Kicker::OPTION_PARSER.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.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 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')
-    @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
-
-describe "Kicker, when a change occurs" do
-  before do
-    Kicker.any_instance.stubs(:last_command_succeeded?).returns(true)
-    Kicker.any_instance.stubs(:log)
-    @kicker = Kicker.new(:paths => %w{ /some/file.rb /some/dir }, :command => 'ls -l')
-  end
-  
-  it "should execute the command if a change occured to a watched path which is a file" do
-    event = stub('Event', :last_modified_file => '/some/file.rb')
-    
-    @kicker.expects(:`).with(@kicker.command).returns('')
-    @kicker.send(:process, [event])
-  end
-  
-  it "should execute the command if a change occured to some file in watched path which is a directory" do
-    event = stub('Event', :last_modified_file => '/some/dir/with/file.rb')
-    
-    @kicker.expects(:`).with(@kicker.command).returns('')
-    @kicker.send(:process, [event])
-  end
-  
-  it "should _not_ execute the command if a change occured to a file that isn't being watched" do
-    event1 = stub('Event', :last_modified_file => '/some/other_file.rb')
-    event2 = stub('Event', :last_modified_file => '/some/not/watched/dir/with/file.rb')
-    
-    @kicker.expects(:`).never
-    @kicker.send(:process, [event1, event2])
-  end
-end
-
-describe "Kicker, in general" do
-  before do
-    Kicker.any_instance.stubs(:last_command_succeeded?).returns(true)
-    @kicker = Kicker.new(:paths => %w{ /some/dir }, :command => 'ls -l')
-  end
-  
-  it "should print a log entry with timestamp" do
-    now = Time.now
-    Time.stubs(:now).returns(now)
-    
-    @kicker.expects(:puts).with("[#{now}] the message")
-    @kicker.send(:log, 'the message')
-  end
-  
-  it "should log the output of the command indented by 2 spaces and whether or not the command succeeded" do
-    @kicker.stubs(:`).returns("line 1\nline 2")
-    
-    @kicker.expects(:log).with('Change occured. Executing command:')
-    @kicker.expects(:log).with('  line 1')
-    @kicker.expects(:log).with('  line 2')
-    @kicker.expects(:log).with('Command succeeded')
-    @kicker.send(:execute!)
-    
-    @kicker.stubs(:last_command_succeeded?).returns(false)
-    @kicker.stubs(:last_command_status).returns(123)
-    @kicker.expects(:log).with('Change occured. Executing command:')
-    @kicker.expects(:log).with('  line 1')
-    @kicker.expects(:log).with('  line 2')
-    @kicker.expects(:log).with('Command failed (123)')
-    @kicker.send(:execute!)
-  end
-  
-  it "should send the Growl messages with the default click callback" do
-    @kicker.stubs(:log)
-    
-    @kicker.stubs(:`).returns("line 1\nline 2")
-    @kicker.use_growl = true
-    
-    OSX::NSWorkspace.sharedWorkspace.expects(:launchApplication).with('Terminal').times(2)
-    
-    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command')
-    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:succeeded], 'Kicker: Command succeeded', "line 1\nline 2").yields
-    @kicker.send(:execute!)
-    
-    @kicker.stubs(:last_command_succeeded?).returns(false)
-    @kicker.stubs(:last_command_status).returns(123)
-    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command')
-    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:failed], 'Kicker: Command failed (123)', "line 1\nline 2").yields
-    @kicker.send(:execute!)
-  end
-  
-  it "should send the Growl messages with a click callback which executes the specified growl command when succeeded" do
-    @kicker.stubs(:log)
-    
-    @kicker.stubs(:`).returns("line 1\nline 2")
-    @kicker.use_growl = true
-    @kicker.growl_command = 'ls -l'
-    
-    @kicker.expects(:system).with('ls -l').times(1)
-    OSX::NSWorkspace.sharedWorkspace.expects(:launchApplication).with('Terminal').times(1)
-    
-    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command')
-    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:succeeded], 'Kicker: Command succeeded', "line 1\nline 2").yields
-    @kicker.send(:execute!)
-    
-    @kicker.stubs(:last_command_succeeded?).returns(false)
-    @kicker.stubs(:last_command_status).returns(123)
-    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured', 'Executing command')
-    @kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:failed], 'Kicker: Command failed (123)', "line 1\nline 2").yields
-    @kicker.send(:execute!)
-  end
-end