alloy-kicker 0.1.1 → 1.0.0

data/LICENSE

@@ -1,3 +1,5 @@
+Kicker:
+
 Copyright (c) 2009 Eloy Duran <eloy.de.enige@gmail.com>
 
 Permission is hereby granted, free of charge, to any person obtaining
@@ -18,3 +20,35 @@ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+======================================================================
+
+Rucola: http://github.com/alloy/rucola/tree/master
+
+Copyright (c) 2008 Eloy Duran <eloy.de.enige@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+======================================================================
+
+growlnotifier: http://github.com/psychs/growlnotifier/tree/master
+
+Copyright (c) 2007-2008 Satoshi Nakagawa <psychs@limechat.net>, Eloy Duran <e.duran@superalloy.nl>
+You can redistribute it and/or modify it under the same terms as Ruby.

data/README.rdoc

@@ -1,24 +1,33 @@
-= kicker
+= Kicker
 
 A simple OS X CLI tool which uses FSEvents to run a given shell command.
 
-Give it a path to a file or directory and a shell command to execute when any
-changes occur:
+== Usage
+
+At the least give it a path to a file or directory and a shell command to
+execute when any changes occur.
+
+  Usage: kicker [options] -e [command] [path]
+      -e, --execute [COMMAND]          The command to execute.
+          --[no-]growl                 Whether or not to use Growl. Default is to use growl.
+          --growl-message [MESSAGE]    The message to Growl when the command succeeded.
+          --growl-command [COMMAND]    The command to execute when the Growl succeeded message is clicked.
+
+== Examples
 
 Show all files whenever a change occurs in the current work directory:
 
-  $ kicker . "ls -l"
+  $ kicker -e "ls -l" .
 
 Run a Rake task whenever a given file is changed:
 
-  $ kicker guides/source/nested_model_forms.textile "ONLY=nested_model_forms rake guides && open -a Safari guides/output/nested_model_forms.html"
+  $ kicker -e "ONLY=nested_model_forms rake guides" guides/source/nested_model_forms.textile
 
-== Installation
+Run a Run task whenever a given file is changed and specify a command to be
+executed if the user clicks a `succeeded' Growl message:
 
-  $ sudo gem install alloy-kicker -s http://gems.github.com
+  $ kicker -e "ONLY=nested_model_forms rake guides" --growl-command "open -a Safari guides/output/nested_model_forms.html" guides/source/nested_model_forms.textile
 
-== Tests??
+== Installation
 
-For now it's just a very simple bin script which uses the FSEvents abstraction
-from Rucola, which is tested there. Once/if this will every be developed
-further test cases will be added where appropriate.
+  $ sudo gem install alloy-kicker -s http://gems.github.com

data/Rakefile

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'rake'
+require 'rake/testtask'
 
 begin
   require 'jeweler'
@@ -16,4 +17,12 @@ begin
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.options = '-rs'
+end
+
+task :default => :test

data/VERSION.yml

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

data/bin/kicker

@@ -1,33 +1,4 @@
 #!/usr/bin/env ruby
 
-require File.expand_path('../../vendor/rucola/fsevents', __FILE__)
-
-path, command = ARGV
-
-unless path && command
-  puts "Usage: #{$0} [PATH] [COMMAND]"
-  exit
-else
-  unless File.exist?(path)
-    puts "The given path `#{path}' does not exist."
-    exit 1
-  end
-end
-
-path = File.expand_path(path)
-file, path = path, File.dirname(path) unless File.directory?(path)
-
-puts "Watching for changes on `#{file || path}'"
-
-stream = Rucola::FSEvents.start_watching(path) do |events|
-  unless file && !events.find { |e| e.last_modified_file == file }
-    system command
-  end
-end
-
-trap("INT") do
-  stream.stop
-  exit
-end
-
-OSX::NSApplication.sharedApplication.run
+require File.expand_path('../../lib/kicker', __FILE__)
+Kicker.run!

data/kicker.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{kicker}
-  s.version = "0.1.1"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Eloy Duran"]
@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.email = %q{eloy.de.enige@gmail.com}
   s.executables = ["kicker"]
   s.extra_rdoc_files = ["README.rdoc", "LICENSE"]
-  s.files = ["bin", "bin/kicker", "kicker.gemspec", "LICENSE", "pkg", "pkg/kicker-0.1.0.gem", "Rakefile", "README.rdoc", "vendor", "vendor/rucola", "vendor/rucola/fsevents.rb", "VERSION.yml"]
+  s.files = ["bin", "bin/kicker", "kicker.gemspec", "lib", "lib/kicker.rb", "LICENSE", "pkg", "pkg/kicker-0.1.0.gem", "pkg/kicker-0.1.1.gem", "Rakefile", "README.rdoc", "test", "test/kicker_test.rb", "test/test_helper.rb", "vendor", "vendor/growlnotifier", "vendor/growlnotifier/growl.rb", "vendor/growlnotifier/growl_helpers.rb", "vendor/rucola", "vendor/rucola/fsevents.rb", "VERSION.yml"]
   s.has_rdoc = true
   s.homepage = %q{http://github.com/alloy/kicker}
   s.rdoc_options = ["--inline-source", "--charset=UTF-8"]

data/lib/kicker.rb

@@ -0,0 +1,140 @@
+$:.unshift File.expand_path('../../vendor', __FILE__)
+require 'rucola/fsevents'
+require 'growlnotifier/growl_helpers'
+require 'optparse'
+
+class Kicker
+  OPTION_PARSER = lambda do |options|
+    OptionParser.new do |opts|
+      opts.banner = "Usage: #{$0} [options] -e [command] [path]"
+      
+      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
+    end
+  end
+  
+  def self.parse_options(argv)
+    argv = argv.dup
+    options = { :growl => true }
+    OPTION_PARSER.call(options).parse!(argv)
+    options[:path] = argv.first
+    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 :path, :file
+  attr_accessor :use_growl, :growl_command
+  
+  def initialize(options)
+    self.path      = options[:path] if options[:path]
+    @command       = options[:command]
+    @use_growl     = options[:growl]
+    @growl_command = options[:growl_command]
+  end
+  
+  def path=(path)
+    @path = File.expand_path(path)
+    @file, @path = @path, File.dirname(@path) unless File.directory?(@path)
+  end
+  
+  def start
+    validate_options!
+    
+    log "Watching for changes on `#{file || path}'"
+    log "With command: #{command}"
+    log ''
+    
+    watch_dog = Rucola::FSEvents.start_watching(path) { |events| process(events) }
+    
+    trap('INT') do
+      log "Cleaning up…"
+      watch_dog.stop
+      exit
+    end
+    
+    Growl::Notifier.sharedInstance.register('Kicker', Kicker::GROWL_NOTIFICATIONS.values) if @use_growl
+    
+    OSX.CFRunLoopRun
+  end
+  
+  def command
+    "sh -c #{@command.inspect}"
+  end
+  
+  def process(events)
+    execute! unless file && !events.find { |e| e.last_modified_file == file }
+  end
+  
+  def log(message)
+    puts "[#{Time.now}] #{message}"
+  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
+    end
+  end
+  
+  def last_command_succeeded?
+    $?.success?
+  end
+  
+  def last_command_status
+    $?.to_i
+  end
+  
+  def validate_options!
+    validate_path_and_command!
+    validate_path_exists!
+  end
+  
+  def validate_path_and_command!
+    unless @path && @command
+      puts OPTION_PARSER.call(nil).help
+      exit
+    end
+  end
+  
+  def validate_path_exists!
+    unless File.exist?(@path)
+      puts "The given path `#{@path}' does not exist"
+      exit 1
+    end
+  end
+end

data/test/kicker_test.rb

@@ -0,0 +1,224 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Kicker.parse_options" do
+  it "should parse the path" do
+    Kicker.parse_options(['/some/file.rb'])[:path].should == '/some/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(:path => '/some/dir', :command => 'ls -l')
+  end
+  
+  it "should return the path to watch" do
+    File.stubs(:directory?).with('/some/dir').returns(true)
+    Kicker.new(:path => '/some/dir').path.should == '/some/dir'
+  end
+  
+  it "should return the command to execute once a change occurs" do
+    Kicker.new(:command => 'ls -l').command.should == 'sh -c "ls -l"'
+  end
+  
+  it "should return the dirname of the path if the given path is a file" do
+    File.stubs(:directory?).with('/some/file.rb').returns(false)
+    Kicker.new(:path => '/some/file.rb').path.should == '/some'
+  end
+  
+  it "should return the path to the file if the given path is a file" do
+    @kicker = Kicker.new(:path => '/some/file.rb', :command => 'ls -l')
+    @kicker.file.should == '/some/file.rb'
+  end
+end
+
+describe "Kicker, when starting" do
+  before do
+    @kicker = Kicker.new(:path => '/some/file.rb', :command => 'ls -l')
+    @kicker.stubs(:log)
+    Rucola::FSEvents.stubs(:start_watching)
+    OSX.stubs(:CFRunLoopRun)
+  end
+  
+  it "should show the usage banner when path and command are nil and exit" do
+    @kicker.instance_variable_set("@path", nil)
+    @kicker.command = nil
+    @kicker.stubs(:validate_path_exists!)
+    
+    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 if the given path doesn't exist and exit" do
+    @kicker.expects(:puts).with("The given path `#{@kicker.path}' does not exist")
+    @kicker.expects(:exit).with(1)
+    
+    @kicker.start
+  end
+  
+  it "should start a FSEvents stream with a block which calls #process with the events" do
+    @kicker.stubs(:validate_options!)
+    
+    Rucola::FSEvents.expects(:start_watching).with(@kicker.path).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
+    File.stubs(:directory?).returns(false)
+    Kicker.any_instance.stubs(:last_command_succeeded?).returns(true)
+    Kicker.any_instance.stubs(:log)
+    @kicker = Kicker.new(:path => '/some/file.rb', :command => 'ls -l')
+  end
+  
+  it "should execute the command if a change occured to the watched file" do
+    event = mock('Rucola::FSEvents::Event', :last_modified_file => '/some/file.rb')
+    
+    @kicker.expects(:`).with(@kicker.command).returns('')
+    @kicker.process([event])
+  end
+  
+  it "should _not_ execute the command if a change occured to another file than the one being watched" do
+    event = mock('Rucola::FSEvents::Event', :last_modified_file => '/some/other_file.rb')
+    
+    @kicker.expects(:`).never
+    @kicker.process([event])
+  end
+  
+  it "should execute the command if a change occured in the watched directory" do
+    File.stubs(:directory?).returns(true)
+    kicker = Kicker.new(:path => '/some/dir', :command => 'ls -l')
+    event = mock('Rucola::FSEvents::Event')
+    
+    kicker.expects(:`).with(kicker.command).returns('')
+    kicker.process([event])
+  end
+end
+
+describe "Kicker, in general" do
+  before do
+    Kicker.any_instance.stubs(:last_command_succeeded?).returns(true)
+    @kicker = Kicker.new(:path => '/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.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!
+    
+    @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!
+  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!
+    
+    @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!
+  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!
+    
+    @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!
+  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/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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: alloy-kicker
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors: 
 - Eloy Duran
@@ -26,12 +26,21 @@ files:
 - bin
 - bin/kicker
 - kicker.gemspec
+- lib
+- lib/kicker.rb
 - LICENSE
 - pkg
 - pkg/kicker-0.1.0.gem
+- pkg/kicker-0.1.1.gem
 - Rakefile
 - README.rdoc
+- test
+- test/kicker_test.rb
+- test/test_helper.rb
 - vendor
+- vendor/growlnotifier
+- vendor/growlnotifier/growl.rb
+- vendor/growlnotifier/growl_helpers.rb
 - vendor/rucola
 - vendor/rucola/fsevents.rb
 - VERSION.yml