kicker 2.0.0

data/test/recipes/rails_test.rb

@@ -0,0 +1,73 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+before = Kicker.process_chain.dup
+require 'kicker/recipes/rails'
+RAILS = (Kicker.process_chain - before).first
+
+describe "The Rails helper module" do
+  it "should return all functional tests" do
+    Dir.expects(:glob).with("test/functional/**/*_test.rb").returns(%w{ test.rb })
+    Rails.all_functional_tests.should == %w{ test.rb }
+  end
+end
+
+describe "The rails handler" do
+  before do
+    @files = %w{ Rakefile }
+  end
+  
+  it "should match any test case files" do
+    should_match %w{ test/1_test.rb test/namespace/2_test.rb },
+                 %w{ test/1_test.rb test/namespace/2_test.rb }
+  end
+  
+  it "should map model files to test/unit" do
+    should_match %w{ app/models/member.rb     app/models/article.rb },
+                 %w{ test/unit/member_test.rb test/unit/article_test.rb }
+  end
+  
+  it "should map concern files to test/unit/concerns" do
+    should_match %w{ app/concerns/authenticate.rb            app/concerns/nested_resource.rb },
+                 %w{ test/unit/concerns/authenticate_test.rb test/unit/concerns/nested_resource_test.rb }
+  end
+  
+  it "should map helper files to test/unit/helpers" do
+    should_match %w{ app/helpers/members_helper.rb             app/helpers/articles_helper.rb },
+                 %w{ test/unit/helpers/members_helper_test.rb  test/unit/helpers/articles_helper_test.rb }
+  end
+  
+  it "should map controller files to test/functional" do
+    should_match %w{ app/controllers/application_controller.rb      app/controllers/members_controller.rb },
+                 %w{ test/functional/application_controller_test.rb test/functional/members_controller_test.rb }
+  end
+  
+  it "should map view templates to test/functional" do
+    should_match %w{ app/views/members/index.html.erb           app/views/admin/articles/show.html.erb },
+                 %w{ test/functional/members_controller_test.rb test/functional/admin/articles_controller_test.rb }
+  end
+  
+  it "should run all functional tests when config/routes.rb is saved" do
+    tests = %w{ test/functional/members_controller_test.rb test/functional/admin/articles_controller_test.rb }
+    Rails.expects(:all_functional_tests).returns(tests)
+    should_match %w{ config/routes.rb }, tests
+  end
+  
+  it "should map lib files to test/lib" do
+    should_match %w{ lib/money.rb           lib/views/date.rb },
+                 %w{ test/lib/money_test.rb test/lib/views/date_test.rb }
+  end
+  
+  private
+  
+  def should_match(files, tests)
+    @files += files
+    
+    tests.each do |test|
+      File.stubs(:exist?).with(test).returns(true)
+    end
+    
+    Kicker::Utils.expects(:run_ruby_tests).with(tests)
+    RAILS.call(@files)
+    @files.should == %w{ Rakefile }
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'test/spec'
+require 'mocha'
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'kicker'

data/test/utils_test.rb

@@ -0,0 +1,123 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "A Kicker instance, concerning its utility methods" do
+  before do
+    Kicker.stubs(:growl)
+    utils.stubs(:last_command_succeeded?).returns(true)
+  end
+  
+  it "should print a log entry with timestamp" do
+    now = Time.now
+    Time.stubs(:now).returns(now)
+    
+    utils.expects(:puts).with("[#{now}] the message")
+    utils.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
+    utils.stubs(:`).returns("line 1\nline 2")
+    
+    utils.expects(:log).with('Change occured, executing command: ls')
+    utils.expects(:log).with('  line 1')
+    utils.expects(:log).with('  line 2')
+    utils.expects(:log).with('Command succeeded')
+    utils.execute('ls')
+    
+    utils.stubs(:last_command_succeeded?).returns(false)
+    utils.stubs(:last_command_status).returns(123)
+    utils.expects(:log).with('Change occured, executing command: ls')
+    utils.expects(:log).with('  line 1')
+    utils.expects(:log).with('  line 2')
+    utils.expects(:log).with('Command failed (123)')
+    utils.execute('ls')
+  end
+  
+  it "should send the Growl messages with the default click callback" do
+    utils.stubs(:log)
+    
+    utils.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:', 'ls')
+    Kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:succeeded], 'Kicker: Command succeeded', "line 1\nline 2").yields
+    utils.execute('ls')
+    
+    utils.stubs(:last_command_succeeded?).returns(false)
+    utils.stubs(:last_command_status).returns(123)
+    Kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured, executing command:', 'ls')
+    Kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:failed], 'Kicker: Command failed (123)', "line 1\nline 2").yields
+    utils.execute('ls')
+  end
+  
+  it "should send the Growl messages with a click callback which executes the specified growl command when succeeded" do
+    utils.stubs(:log)
+    
+    utils.stubs(:`).returns("line 1\nline 2")
+    Kicker.use_growl = true
+    Kicker.growl_command = 'ls -l'
+    
+    utils.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:', 'ls')
+    Kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:succeeded], 'Kicker: Command succeeded', "line 1\nline 2").yields
+    utils.execute('ls')
+    
+    utils.stubs(:last_command_succeeded?).returns(false)
+    utils.stubs(:last_command_status).returns(123)
+    Kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:change], 'Kicker: Change occured, executing command:', 'ls')
+    Kicker.expects(:growl).with(Kicker::GROWL_NOTIFICATIONS[:failed], 'Kicker: Command failed (123)', "line 1\nline 2").yields
+    utils.execute('ls')
+  end
+  
+  it "should store the last executed command" do
+    utils.stubs(:log)
+    utils.execute('date')
+    utils.last_command.should == 'date'
+  end
+  
+  private
+  
+  def utils
+    Kicker::Utils
+  end
+end
+
+describe "Kernel utility methods" do
+  before do
+    utils.stubs(:last_command_succeeded?).returns(true)
+  end
+  
+  it "should forward log calls to the Kicker::Utils module" do
+    utils.expects(:log).with('the message')
+    log 'the message'
+  end
+  
+  it "should forward execute calls to the Kicker::Utils module" do
+    utils.expects(:execute).with('ls')
+    execute 'ls'
+  end
+  
+  it "should return the last_command" do
+    utils.stubs(:last_command).returns('abcde')
+    last_command.should == 'abcde'
+  end
+  
+  it "should call execute with the appropriate command to execute Ruby tests" do
+    utils.expects(:execute).with("ruby -r test/1.rb -r test/2.rb -e ''")
+    run_ruby_tests %w{ test/1.rb test/2.rb }
+  end
+  
+  it "should not execute anything if an empty array is given to run_ruby_tests" do
+    utils.expects(:execute).never
+    run_ruby_tests []
+  end
+  
+  private
+  
+  def utils
+    Kicker::Utils
+  end
+end

data/vendor/growlnotifier/growl.rb

@@ -0,0 +1,170 @@
+require 'osx/cocoa'
+
+module Growl
+  class Notifier < OSX::NSObject
+    VERSION = '1.0.2'
+    
+    GROWL_IS_READY = "Lend Me Some Sugar; I Am Your Neighbor!"
+    GROWL_NOTIFICATION_CLICKED = "GrowlClicked!"
+    GROWL_NOTIFICATION_TIMED_OUT = "GrowlTimedOut!"
+    GROWL_KEY_CLICKED_CONTEXT = "ClickedContext"
+    
+    PRIORITIES = {
+      :emergency =>  2,
+      :high      =>  1,
+      :normal    =>  0,
+      :moderate  => -1,
+      :very_low  => -2,
+    }
+    
+    class << self
+      # Returns the singleton instance of Growl::Notifier with which you register and send your Growl notifications.
+      def sharedInstance
+        @sharedInstance ||= alloc.init
+      end
+    end
+    
+    attr_reader :application_name, :application_icon, :notifications, :default_notifications
+    attr_accessor :delegate
+    
+    # Set to +true+ if you want to receive delegate callback messages,
+    # <tt>growlNotifierClicked_context</tt> & <tt>growlNotifierTimedOut_context</tt>,
+    # without the need to specify a <tt>:click_context</tt>.
+    #
+    # The default is +false+, which means your application won't receive any delegate
+    # callback messages if the <tt>:click_context</tt> is omitted.
+    attr_accessor :always_callback
+    
+    # Registers the applications metadata and the notifications, that your application might send, to Growl.
+    # The +default_notifications+ are notifications that will be enabled by default, the regular +notifications+ are
+    # optional and should be enabled by the user in the Growl system preferences.
+    #
+    # Register the applications name and the notifications that will be used.
+    # * +default_notifications+ defaults to the regular +notifications+.
+    # * +application_icon+ defaults to OSX::NSApplication.sharedApplication.applicationIconImage.
+    #
+    #   Growl::Notifier.sharedInstance.register 'FoodApp', ['YourHamburgerIsReady', 'OhSomeoneElseAteIt']
+    #
+    # Register the applications name, the notifications plus the default notifications that will be used and the icon that's to be used in the Growl notifications.
+    #
+    #   Growl::Notifier.sharedInstance.register 'FoodApp', ['YourHamburgerIsReady', 'OhSomeoneElseAteIt'], ['DefaultNotification], OSX::NSImage.imageNamed('GreasyHamburger')
+    def register(application_name, notifications, default_notifications = nil, application_icon = nil)
+      @application_name, @application_icon = application_name, (application_icon || OSX::NSApplication.sharedApplication.applicationIconImage)
+      @notifications, @default_notifications = notifications, (default_notifications || notifications)
+      @callbacks = {}
+      send_registration!
+    end
+    
+    # Sends a Growl notification.
+    #
+    # * +notification_name+ : the name of one of the notifcations that your apllication registered with Growl. See register for more info.
+    # * +title+ : the title that should be used in the Growl notification.
+    # * +description+ : the body of the Grow notification.
+    # * +options+ : specifies a few optional options:
+    #   * <tt>:sticky</tt> : indicates if the Grow notification should "stick" to the screen. Defaults to +false+.
+    #   * <tt>:priority</tt> : sets the priority level of the Growl notification. Defaults to 0.
+    #   * <tt>:click_context</tt> : a string describing the context of the notification. This is send back to the delegate so you can check what kind of notification it was. If omitted, no delegate messages will be send. You can disable this behaviour by setting always_callback to +true+.
+    #   * <tt>:icon</tt> : specifies the icon to be used in the Growl notification. Defaults to the registered +application_icon+, see register for more info.
+    #
+    # Simple example:
+    #
+    #   name = 'YourHamburgerIsReady'
+    #   title = 'Your hamburger is ready for consumption!'
+    #   description = 'Please pick it up at isle 4.'
+    #   
+    #   Growl::Notifier.sharedInstance.notify(name, title, description)
+    #
+    # Example with optional options:
+    #
+    #   Growl::Notifier.sharedInstance.notify(name, title, description, :sticky => true, :priority => 1, :icon => OSX::NSImage.imageNamed('SuperBigHamburger'))
+    #
+    # When you pass notify a block, that block will be used as the callback handler if the Growl notification was clicked. Eg:
+    #
+    #   Growl::Notifier.sharedInstance.notify(name, title, description, :sticky => true) do
+    #     user_clicked_notification_so_do_something!
+    #   end
+    def notify(notification_name, title, description, options = {}, &callback)
+      dict = {
+        :ApplicationName => @application_name,
+        :ApplicationPID => pid,
+        :NotificationName => notification_name,
+        :NotificationTitle => title,
+        :NotificationDescription => description,
+        :NotificationPriority => PRIORITIES[options[:priority]] || options[:priority] || 0
+      }
+      dict[:NotificationIcon] = options[:icon].TIFFRepresentation if options[:icon]
+      dict[:NotificationSticky] = 1 if options[:sticky]
+      
+      context = {}
+      context[:user_click_context] = options[:click_context] if options[:click_context]
+      if block_given?
+        @callbacks[callback.object_id] = callback
+        context[:callback_object_id] = callback.object_id.to_s
+      end
+      dict[:NotificationClickContext] = context if always_callback || !context.empty?
+      
+      notification_center.postNotificationName_object_userInfo_deliverImmediately(:GrowlNotification, nil, dict, true)
+    end
+    
+    def onReady(notification)
+      send_registration!
+    end
+    
+    def onClicked(notification)
+      user_context = nil
+      if context = notification.userInfo[GROWL_KEY_CLICKED_CONTEXT]
+        user_context = context[:user_click_context]
+        if callback_object_id = context[:callback_object_id]
+          @callbacks.delete(callback_object_id.to_i).call
+        end
+      end
+      
+      @delegate.growlNotifierClicked_context(self, user_context) if @delegate && @delegate.respond_to?(:growlNotifierClicked_context)
+    end
+    
+    def onTimeout(notification)
+      user_context = nil
+      if context = notification.userInfo[GROWL_KEY_CLICKED_CONTEXT]
+        @callbacks.delete(context[:callback_object_id].to_i) if context[:callback_object_id]
+        user_context = context[:user_click_context]
+      end
+      
+      @delegate.growlNotifierTimedOut_context(self, user_context) if @delegate && @delegate.respond_to?(:growlNotifierTimedOut_context)
+    end
+    
+    private
+    
+    def pid
+      OSX::NSProcessInfo.processInfo.processIdentifier.to_i
+    end
+    
+    def notification_center
+      OSX::NSDistributedNotificationCenter.defaultCenter
+    end
+    
+    def send_registration!
+      add_observer 'onReady:', GROWL_IS_READY, false
+      add_observer 'onClicked:', GROWL_NOTIFICATION_CLICKED, true
+      add_observer 'onTimeout:', GROWL_NOTIFICATION_TIMED_OUT, true
+      
+      dict = {
+        :ApplicationName => @application_name,
+        :ApplicationIcon => application_icon.TIFFRepresentation,
+        :AllNotifications => @notifications,
+        :DefaultNotifications => @default_notifications
+      }
+      
+      notification_center.objc_send(
+        :postNotificationName, :GrowlApplicationRegistrationNotification,
+                      :object, nil,
+                    :userInfo, dict,
+          :deliverImmediately, true
+      )
+    end
+    
+    def add_observer(selector, name, prepend_name_and_pid)
+      name = "#{@application_name}-#{pid}-#{name}" if prepend_name_and_pid
+      notification_center.addObserver_selector_name_object self, selector, name, nil
+    end
+  end
+end

data/vendor/growlnotifier/growl_helpers.rb

@@ -0,0 +1,25 @@
+require File.expand_path('../growl', __FILE__)
+
+# Defines a few convenience methods that you can use in your class if you include the Growl module.
+# Eg:
+#
+#   class FoodReporter < OSX::NSObject
+#     include Growl
+#
+#     def hamburger_time!
+#       growl 'YourHamburgerIsReady', 'Your hamburger is ready for consumption!', 'Please pick it up at isle 4.', :priority => 1 do
+#         throw_it_away_before_user_reaches_counter!
+#       end
+#     end
+#   end
+module Growl
+  # Sends a Growl notification. See Growl::Notifier#notify for more info.
+  def growl(name, title, description, options = {}, &callback)
+    Growl::Notifier.sharedInstance.notify name, title, description, options, &callback
+  end
+  
+  # Sends a sticky Growl notification. See Growl::Notifier#notify for more info.
+  def sticky_growl(name, title, description, options = {}, &callback)
+    growl name, title, description, options.merge!(:sticky => true), &callback
+  end
+end

data/vendor/rucola/fsevents.rb

@@ -0,0 +1,136 @@
+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