kicker 2.3.0 → 2.3.1

data/README.rdoc

@@ -2,7 +2,7 @@
 
 A lean, agnostic, flexible file-change watcher, using OS X FSEvents.
 
-http://github.com/alloy/kicker/raw/master/html/images/kikker.jpg
+https://github.com/alloy/kicker/raw/master/html/images/kikker.jpg
 
 Meet king kikker, kicking stuff in your computers is his dream come true!
 

data/Rakefile

@@ -14,6 +14,7 @@ begin
     gem.files.concat FileList['vendor/**/*']
     gem.require_paths = ["lib", "vendor"]
     gem.has_rdoc = true
+    gem.add_dependency 'rb-fsevent'
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
@@ -33,4 +34,4 @@ namespace :docs do
   end
 end
 
-task :default => :test
+task :default => :test

data/VERSION

@@ -1 +1 @@
-2.3.0
+2.3.1

data/bin/kicker

@@ -1,5 +1,10 @@
 #!/usr/bin/env ruby
-$:.unshift File.expand_path('../../lib', __FILE__) if $0 == __FILE__
+
+if $0 == __FILE__
+  $:.unshift File.expand_path('../../lib', __FILE__)
+  $:.unshift File.expand_path('../../vendor', __FILE__)
+  require 'rubygems'
+end
 
 require 'kicker'
 Kicker.run

data/kicker.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{kicker}
-  s.version = "2.3.0"
+  s.version = "2.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Eloy Duran"]
-  s.date = %q{2010-07-27}
+  s.date = %q{2011-05-27}
   s.default_executable = %q{kicker}
   s.email = %q{eloy.de.enige@gmail.com}
   s.executables = ["kicker"]
@@ -31,6 +31,7 @@ Gem::Specification.new do |s|
      "lib/kicker.rb",
      "lib/kicker/callback_chain.rb",
      "lib/kicker/core_ext.rb",
+     "lib/kicker/fsevents.rb",
      "lib/kicker/growl.rb",
      "lib/kicker/log_status_helper.rb",
      "lib/kicker/options.rb",
@@ -47,6 +48,7 @@ Gem::Specification.new do |s|
      "test/core_ext_test.rb",
      "test/filesystem_change_test.rb",
      "test/fixtures/a_file_thats_reloaded.rb",
+     "test/fsevents_test.rb",
      "test/growl_test.rb",
      "test/initialization_test.rb",
      "test/log_status_helper_test.rb",
@@ -62,19 +64,19 @@ Gem::Specification.new do |s|
      "test/test_helper.rb",
      "test/utils_test.rb",
      "vendor/growlnotifier/growl.rb",
-     "vendor/growlnotifier/growl_helpers.rb",
-     "vendor/rucola/fsevents.rb"
+     "vendor/growlnotifier/growl_helpers.rb"
   ]
   s.homepage = %q{http://github.com/alloy/kicker}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib", "vendor"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{A lean, agnostic, flexible file-change watcher, using OS X FSEvents.}
   s.test_files = [
     "test/callback_chain_test.rb",
      "test/core_ext_test.rb",
      "test/filesystem_change_test.rb",
      "test/fixtures/a_file_thats_reloaded.rb",
+     "test/fsevents_test.rb",
      "test/growl_test.rb",
      "test/initialization_test.rb",
      "test/log_status_helper_test.rb",
@@ -95,10 +97,13 @@ Gem::Specification.new do |s|
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rb-fsevent>, [">= 0"])
     else
+      s.add_dependency(%q<rb-fsevent>, [">= 0"])
     end
   else
+    s.add_dependency(%q<rb-fsevent>, [">= 0"])
   end
 end
 

data/lib/kicker.rb

@@ -1,6 +1,6 @@
 $:.unshift File.expand_path('../../vendor', __FILE__)
-require 'rucola/fsevents'
 
+require 'kicker/fsevents'
 require 'kicker/callback_chain'
 require 'kicker/core_ext'
 require 'kicker/growl'
@@ -30,11 +30,9 @@ class Kicker #:nodoc:
     log "Watching for changes on: #{paths.join(', ')}"
     log ''
     
-    run_watch_dog!
     Kicker::Growl.start! if Kicker::Growl.use?
     run_startup_chain
-    
-    OSX.CFRunLoopRun
+    run_watch_dog!
   end
   
   private
@@ -62,12 +60,12 @@ class Kicker #:nodoc:
   
   def run_watch_dog!
     dirs = @paths.map { |path| File.directory?(path) ? path : File.dirname(path) }
-    watch_dog = Rucola::FSEvents.start_watching(dirs, :latency => self.class.latency) do |events|
+    watch_dog = Kicker::FSEvents.start_watching(dirs, :latency => self.class.latency) do |events|
       process events
     end
     
     trap('INT') do
-      log "Exiting…"
+      log "Exiting ..."
       watch_dog.stop
       exit
     end
@@ -121,4 +119,4 @@ end
 
 # Load this as last, because it actually loads all recipes, so everything has
 # to be defined before that.
-require 'kicker/recipes'
+require 'kicker/recipes'

data/lib/kicker/fsevents.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'rb-fsevent'
+
+class Kicker
+  class FSEvents
+    class FSEvent
+      attr_reader :path
+      
+      def initialize(path)
+        @path = path
+      end
+      
+      def files
+        Dir.glob("#{File.expand_path(path)}/*").map do |filename|
+          begin
+            [File.mtime(filename), filename]
+          rescue Errno::ENOENT
+            nil
+          end
+        end.compact.sort.reverse.map { |_, filename| filename }
+      end
+    end
+    
+    def self.start_watching(paths, options={}, &block)
+      fsevent = ::FSEvent.new
+      fsevent.watch(paths, options) do |directories|
+        yield directories.map { |directory| Kicker::FSEvents::FSEvent.new(directory) }
+      end
+      fsevent.run
+    end
+  end
+end

data/lib/kicker/growl.rb

@@ -1,59 +1,79 @@
-require 'growlnotifier/growl_helpers'
-
 class Kicker
   module Growl #:nodoc:
-    NOTIFICATIONS = {
-      :change => 'Change occured',
-      :succeeded => 'Command succeeded',
-      :failed => 'Command failed'
-    }
-    
-    DEFAULT_CALLBACK = lambda do
-      OSX::NSWorkspace.sharedWorkspace.launchApplication('Terminal')
-    end
-    
     class << self
-      include ::Growl
       attr_accessor :use, :command
       
-      Growl.use = true
-      Growl.command = nil
+      def usable?
+        false
+      end
       
       def use?
         @use
       end
+    end
+  end
+end
+
+begin
+  require 'osx/cocoa'
+  require 'growlnotifier/growl_helpers'
+
+  class Kicker
+    module Growl #:nodoc:
+      NOTIFICATIONS = {
+        :change => 'Change occured',
+        :succeeded => 'Command succeeded',
+        :failed => 'Command failed'
+      }
       
-      def notifications
-        NOTIFICATIONS
-      end
-      
-      def start!
-        ::Growl::Notifier.sharedInstance.register('Kicker', NOTIFICATIONS.values)
-      end
-      
-      def change_occured(status)
-        growl(notifications[:change], 'Kicker: Executing', status.call(:growl) || status.command)
-      end
-      
-      def command_callback
-        lambda { system(command) } if command
-      end
-      
-      def result(status)
-        status.success? ? succeeded(status) : failed(status)
-      end
-      
-      def succeeded(status)
-        callback = command_callback || DEFAULT_CALLBACK
-        body = status.call(:growl) || (Kicker.silent? ? '' : status.output)
-        growl(notifications[:succeeded], "Kicker: Success", body, &callback)
+      DEFAULT_CALLBACK = lambda do
+        OSX::NSWorkspace.sharedWorkspace.launchApplication('Terminal')
       end
       
-      def failed(status)
-        message = "Kicker: Failed (#{status.exit_code})"
-        body = status.call(:growl) || (Kicker.silent? ? '' : status.output)
-        growl(notifications[:failed], message, body, &DEFAULT_CALLBACK)
+      class << self
+        include ::Growl
+        
+        Growl.use = true
+        Growl.command = nil
+        
+        def usable?
+          true
+        end
+        
+        def notifications
+          NOTIFICATIONS
+        end
+        
+        def start!
+          ::Growl::Notifier.sharedInstance.register('Kicker', NOTIFICATIONS.values)
+        end
+        
+        def change_occured(status)
+          growl(notifications[:change], 'Kicker: Executing', status.call(:growl) || status.command)
+        end
+        
+        def command_callback
+          lambda { system(command) } if command
+        end
+        
+        def result(status)
+          status.success? ? succeeded(status) : failed(status)
+        end
+        
+        def succeeded(status)
+          callback = command_callback || DEFAULT_CALLBACK
+          body = status.call(:growl) || (Kicker.silent? ? '' : status.output)
+          growl(notifications[:succeeded], "Kicker: Success", body, &callback)
+        end
+        
+        def failed(status)
+          message = "Kicker: Failed (#{status.exit_code})"
+          body = status.call(:growl) || (Kicker.silent? ? '' : status.output)
+          growl(notifications[:failed], message, body, &DEFAULT_CALLBACK)
+        end
       end
     end
   end
-end
+
+rescue LoadError
+end

data/lib/kicker/options.rb

@@ -15,6 +15,10 @@ class Kicker
     def clear_console?
       @clear_console
     end
+    
+    def has_growl?
+      Kicker.const_defined?(:Growl)
+    end
   end
   
   self.latency = 1
@@ -49,12 +53,16 @@ class Kicker
           Kicker.clear_console = true
         end
         
-        opt.on('--[no-]growl', 'Whether or not to use Growl. Default is to use growl.') do |growl|
-          Kicker::Growl.use = growl
-        end
-        
-        opt.on('--growl-command [COMMAND]', 'The command to execute when the Growl succeeded message is clicked.') do |command|
-          Kicker::Growl.command = command
+        if Kicker::Growl.usable?
+          opt.on('--[no-]growl', 'Whether or not to use Growl. Default is to use growl.') do |growl|
+            Kicker::Growl.use = growl
+          end
+          
+          opt.on('--growl-command [COMMAND]', 'The command to execute when the Growl succeeded message is clicked.') do |command|
+            Kicker::Growl.command = command
+          end
+        else
+          Kicker::Growl.use = false
         end
         
         opt.on('-l', '--latency [FLOAT]', "The time to collect file change events before acting on them. Defaults to #{Kicker.latency} second.") do |latency|

data/test/fsevents_test.rb

@@ -0,0 +1,35 @@
+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,85 +1,89 @@
 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)
+if Kicker::Growl.usable?
+  describe "Kicker::Growl" do
+    before do
+      @growler = Kicker::Growl
+    end
     
-    OSX::NSWorkspace.sharedWorkspace.expects(:launchApplication).with('Terminal')
-    @growler.expects(:growl).with(
-      @growler.notifications[:succeeded],
-      'Kicker: Success',
-      "line 1\nline 2"
-    ).yields
+    after do
+      Kicker.silent = false
+    end
     
-    @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)
+    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
     
-    OSX::NSWorkspace.sharedWorkspace.expects(:launchApplication).with('Terminal')
-    @growler.expects(:growl).with(
-      @growler.notifications[:failed],
-      'Kicker: Failed (123)',
-      "line 1\nline 2"
-    ).yields
+    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
     
-    @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)
+    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
     
-    @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)
+    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
     
-    @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)
+    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
     
-    @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)
+    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
     
-    @growler.expects(:growl).with(@growler.notifications[:failed], 'Kicker: Failed (123)', 'foo')
-    @growler.failed(status)
+    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
+else
+  puts "Poo"
 end

data/test/initialization_test.rb

@@ -42,8 +42,7 @@ describe "Kicker, when starting" do
     @kicker = Kicker.new
     @kicker.stubs(:log)
     @kicker.startup_chain.stubs(:call)
-    Rucola::FSEvents.stubs(:start_watching)
-    OSX.stubs(:CFRunLoopRun)
+    Kicker::FSEvents.stubs(:start_watching)
   end
   
   after do
@@ -77,7 +76,7 @@ describe "Kicker, when starting" do
     @kicker.stubs(:validate_options!)
     
     Kicker.latency = 2.34
-    Rucola::FSEvents.expects(:start_watching).with(['/some'], :latency => 2.34)
+    Kicker::FSEvents.expects(:start_watching).with(['/some'], :latency => 2.34)
     @kicker.start
   end
   
@@ -85,14 +84,14 @@ 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)
+    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!)
     
-    Rucola::FSEvents.expects(:start_watching).yields(['event'])
+    Kicker::FSEvents.expects(:start_watching).yields(['event'])
     @kicker.expects(:process).with(['event'])
     
     @kicker.start
@@ -101,8 +100,8 @@ describe "Kicker, when starting" do
   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)
+    watch_dog = stub('Kicker::FSEvents')
+    Kicker::FSEvents.stubs(:start_watching).returns(watch_dog)
     
     @kicker.expects(:trap).with('INT').yields
     watch_dog.expects(:stop)
@@ -111,20 +110,22 @@ describe "Kicker, when starting" do
     @kicker.start
   end
   
-  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
+  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
     
-    Growl::Notifier.sharedInstance.expects(:register).never
-    @kicker.start
+    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
@@ -133,11 +134,4 @@ describe "Kicker, when starting" do
     @kicker.startup_chain.expects(:call).with([], false)
     @kicker.start
   end
-  
-  it "should start a CFRunLoop" do
-    @kicker.stubs(:validate_options!)
-    
-    OSX.expects(:CFRunLoopRun)
-    @kicker.start
-  end
 end

data/test/options_test.rb

@@ -21,12 +21,14 @@ describe "Kicker::Options.parse" do
     Kicker.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::Options.parse([])
-    Kicker::Growl.should.use
+  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
+      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
@@ -55,9 +57,11 @@ describe "Kicker::Options.parse" do
     Kicker.should.clear_console
   end
   
-  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'
+  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

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: kicker
 version: !ruby/object:Gem::Version 
-  version: 2.3.0
+  hash: 1
+  prerelease: false
+  segments: 
+  - 2
+  - 3
+  - 1
+  version: 2.3.1
 platform: ruby
 authors: 
 - Eloy Duran
@@ -9,10 +15,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-27 00:00:00 +02:00
+date: 2011-05-27 00:00:00 +02:00
 default_executable: kicker
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rb-fsevent
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
 description: 
 email: eloy.de.enige@gmail.com
 executables: 
@@ -36,6 +55,7 @@ files:
 - lib/kicker.rb
 - lib/kicker/callback_chain.rb
 - lib/kicker/core_ext.rb
+- lib/kicker/fsevents.rb
 - lib/kicker/growl.rb
 - lib/kicker/log_status_helper.rb
 - lib/kicker/options.rb
@@ -52,6 +72,7 @@ files:
 - test/core_ext_test.rb
 - test/filesystem_change_test.rb
 - test/fixtures/a_file_thats_reloaded.rb
+- test/fsevents_test.rb
 - test/growl_test.rb
 - test/initialization_test.rb
 - test/log_status_helper_test.rb
@@ -68,7 +89,6 @@ files:
 - test/utils_test.rb
 - vendor/growlnotifier/growl.rb
 - vendor/growlnotifier/growl_helpers.rb
-- vendor/rucola/fsevents.rb
 has_rdoc: true
 homepage: http://github.com/alloy/kicker
 licenses: []
@@ -80,21 +100,27 @@ require_paths:
 - lib
 - vendor
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: A lean, agnostic, flexible file-change watcher, using OS X FSEvents.
@@ -103,6 +129,7 @@ test_files:
 - test/core_ext_test.rb
 - test/filesystem_change_test.rb
 - test/fixtures/a_file_thats_reloaded.rb
+- test/fsevents_test.rb
 - test/growl_test.rb
 - test/initialization_test.rb
 - test/log_status_helper_test.rb

data/vendor/rucola/fsevents.rb

@@ -1,136 +0,0 @@
-require 'osx/cocoa'
-OSX.require_framework '/System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework'
-
-module Rucola
-  class FSEvents
-    class FSEvent
-      attr_reader :fsevents_object
-      attr_reader :id
-      attr_reader :path
-      def initialize(fsevents_object, id, path)
-        @fsevents_object, @id, @path = fsevents_object, id, path
-      end
-      
-      # Returns an array of the files/dirs in the path that the event occurred in.
-      # The files are sorted by the modification time, the first entry is the last modified file.
-      def files
-        Dir.glob("#{File.expand_path(path)}/*").map do |filename|
-          begin
-            [File.mtime(filename), filename]
-          rescue Errno::ENOENT
-            nil
-          end
-        end.compact.sort.reverse.map { |mtime, filename| filename }
-      end
-      
-      # Returns the last modified file in the path that the event occurred in.
-      def last_modified_file
-        files.first
-      end
-    end
-    
-    class StreamError < StandardError; end
-    
-    attr_reader :paths
-    attr_reader :stream
-    
-    attr_accessor :allocator
-    attr_accessor :context
-    attr_accessor :since
-    attr_accessor :latency
-    attr_accessor :flags
-    
-    # Initializes a new FSEvents `watchdog` object and starts watching the directories you specify for events. The
-    # block is used as a handler for events, which are passed as the block's argument. This method is the easiest
-    # way to start watching some directories if you don't care about the details of setting up the event stream.
-    #
-    #   Rucola::FSEvents.start_watching('/tmp') do |events|
-    #     events.each { |event| log.debug("#{event.files.inspect} were changed.") }
-    #   end
-    #   
-    #   Rucola::FSEvents.start_watching('/var/log/system.log', '/var/log/secure.log', :since => last_id, :latency => 5) do
-    #     Growl.notify("Something was added to your log files!")
-    #   end
-    #
-    # Note that the method also returns the FSEvents object. This enables you to control the event stream if you want to.
-    #
-    #   fsevents = Rucola::FSEvents.start_watching('/Volumes') do |events|
-    #     events.each { |event| Growl.notify("Volume changes: #{event.files.to_sentence}") }
-    #   end
-    #   fsevents.stop
-    def self.start_watching(*params, &block)
-      fsevents = new(*params, &block)
-      fsevents.create_stream
-      fsevents.start
-      fsevents
-    end
-    
-    # Creates a new FSEvents `watchdog` object. You can specify a list of paths to watch and options to control the
-    # behaviour of the watchdog. The block you pass serves as a callback when an event is generated on one of the
-    # specified paths.
-    #
-    #   fsevents = FSEvents.new('/etc/passwd') { Mailer.send_mail("Someone touched the password file!") }
-    #   fsevents.create_stream
-    #   fsevents.start
-    #
-    #   fsevents = FSEvents.new('/home/upload', :since => UploadWatcher.last_event_id) do |events|
-    #     events.each do |event|
-    #       UploadWatcher.last_event_id = event.id
-    #       event.files.each do |file|
-    #         UploadWatcher.logfile.append("#{file} was changed")
-    #       end
-    #     end
-    #   end
-    #
-    # *:since: The service will report events that have happened after the supplied event ID. Never use 0 because that 
-    #   will cause every fsevent since the "beginning of time" to be reported. Use OSX::KFSEventStreamEventIdSinceNow
-    #   if you want to receive events that have happened after this call. (Default: OSX::KFSEventStreamEventIdSinceNow).
-    #   You can find the ID's passed with :since in the events passed to your block.
-    # *:latency: Number of seconds to wait until an FSEvent is reported, this allows the service to bundle events. (Default: 0.0)
-    #
-    # Please refer to the Cocoa documentation for the rest of the options.
-    def initialize(*params, &block)
-      raise ArgumentError, 'No callback block was specified.' unless block_given?
-      
-      options = params.last.kind_of?(Hash) ? params.pop : {}
-      @paths = params.flatten
-      
-      paths.each { |path| raise ArgumentError, "The specified path (#{path}) does not exist." unless File.exist?(path) }
-      
-      @allocator = options[:allocator] || OSX::KCFAllocatorDefault
-      @context   = options[:context]   || nil
-      @since     = options[:since]     || OSX::KFSEventStreamEventIdSinceNow
-      @latency   = options[:latency]   || 0.0
-      @flags     = options[:flags]     || 0
-      @stream    = options[:stream]    || nil
-      
-      @user_callback = block
-      @callback = Proc.new do |stream, client_callback_info, number_of_events, paths_pointer, event_flags, event_ids|
-        paths_pointer.regard_as('*')
-        events = []
-        number_of_events.times {|i| events << Rucola::FSEvents::FSEvent.new(self, event_ids[i], paths_pointer[i]) }
-        @user_callback.call(events)
-      end
-    end
-    
-    # Create the stream.
-    # Raises a Rucola::FSEvents::StreamError if the stream could not be created.
-    def create_stream
-      @stream = OSX.FSEventStreamCreate(@allocator, @callback, @context, @paths, @since, @latency, @flags)
-      raise(StreamError, 'Unable to create FSEvents stream.') unless @stream
-      OSX.FSEventStreamScheduleWithRunLoop(@stream, OSX.CFRunLoopGetCurrent, OSX::KCFRunLoopDefaultMode)
-    end
-    
-    # Start the stream.
-    # Raises a Rucola::FSEvents::StreamError if the stream could not be started.
-    def start
-      raise(StreamError, 'Unable to start FSEvents stream.') unless OSX.FSEventStreamStart(@stream)
-    end
-    
-    # Stop the stream.
-    # You can resume it by calling `start` again.
-    def stop
-      OSX.FSEventStreamStop(@stream)
-    end
-  end
-end