growlnotifier 1.0

data/LICENSE

@@ -0,0 +1,2 @@
+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/Manifest.txt

@@ -0,0 +1,11 @@
+Manifest.txt
+README.txt
+Rakefile
+LICENSE
+lib/growl.rb
+lib/growl_helpers.rb
+samples/growl_block_sample.rb
+samples/growl_delegate_sample.rb
+test/growl_test.rb
+test/growl_helpers_test.rb
+test/test_helper.rb

data/README.txt

@@ -0,0 +1,69 @@
+= Growl Notifier
+
+== Overview
+
+Growl::Notifier is a class that allows your application to post notifications to the Growl daemon.
+It can also receive clicked and timeout notifications as well as take blocks for clicked callback handlers.
+
+This is an extraction and cleanup of the Growl code from LimeChat (http://github.com/psychs/limechat/tree/master) and later on extended for WebApp (http://github.com/alloy/webapp-app/tree/master).
+
+== Requirements
+
+* Mac OS X 10.4 or 10.5
+* Ruby 1.8 (http://ruby-lang.org/)
+* RubyCocoa (http://rubycocoa.sourceforge.net/)
+
+== How to use Growl Notifier
+
+A simple example:
+
+  require 'growl'
+  
+  g = Growl::Notifier.sharedInstance
+  g.register('test_app', ['message_type'])
+  g.notify('message_type', 'title', 'desc')
+
+How to receive clicked and timeout notifications in your application:
+
+  require 'growl'
+
+  class GrowlController < OSX::NSObject
+    def init
+      if super_init
+        @g = Growl::Notifier.sharedInstance
+        @g.delegate = self
+        @g.register('test_app', ['message_type'])
+        @g.notify('message_type', 'title', 'desc')
+        self
+      end
+    end
+
+    def growlNotifierClicked_context(sender, context)
+      puts context
+    end
+
+    def growlNotifierTimedOut_context(sender, context)
+      puts context
+    end
+  end
+
+Include the Growl module into your class to get access to a few convenience methods:
+
+  require 'growl'
+
+  class GrowlController < OSX::NSObject
+    include Growl
+    Growl::Notifier.sharedInstance.register('test_app', ['message_type'])
+    
+    def init
+      if super_init
+        growl('message_type', 'title', 'desc')
+        self
+      end
+    end
+  end
+
+== License
+
+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/Rakefile

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'rake/testtask'
+
+require 'lib/growl.rb'
+
+# Install the Hoe gem to be able to use the deploy tasks.
+begin
+  require 'hoe'
+  
+  class Hoe
+    def extra_deps
+      @extra_deps.reject do |x|
+        Array(x).first == 'hoe'
+      end
+    end
+  end
+  
+  Hoe.new('growlnotifier', Growl::Notifier::VERSION) do |p|
+    p.author = ["Satoshi Nakagawa", "Eloy Duran"]
+    p.description = "A ruby library which allows you to send Growl notifications."
+    p.email = ["psychs@limechat.net", "e.duran@superalloy.nl"]
+    p.summary = "Growl::Notifier is a OSX RubyCocoa class that allows your application to post notifications to the Growl daemon."
+    p.url = "http://growlnotifier.rubyforge.org/"
+    p.clean_globs = ['coverage'] # Remove this directory on "rake clean"
+    p.remote_rdoc_dir = '' # Release to root
+  end
+rescue LoadError
+end
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.options = '-rs'
+end
+
+desc "Run code-coverage analysis using rcov"
+task :coverage do
+  rm_rf "coverage"
+  sh "rcov test/*_test.rb --exclude=mocha,RubyCocoa.framework,osx,rcov"
+  sh "open coverage/index.html"
+end

data/lib/growl.rb

@@ -0,0 +1,161 @@
+require 'osx/cocoa'
+
+module Growl
+  class Notifier < OSX::NSObject
+    VERSION = '1.0'
+    
+    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
+    
+    # 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>: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 unless 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/lib/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/samples/growl_block_sample.rb

@@ -0,0 +1,29 @@
+require 'osx/cocoa'
+require File.expand_path('../../lib/growl_helpers', __FILE__)
+
+class GrowlController < OSX::NSObject
+  # Makes the #growl and #sticky_growl shortcut methods available.
+  include Growl
+  
+  HELLO_TYPE = 'Hello message received'
+  Growl::Notifier.sharedInstance.register('GrowlSample', [HELLO_TYPE])
+  
+  def init
+    if super_init
+      growl HELLO_TYPE, 'Not sticky', 'Hello world' do
+        puts "Clicked not sticky: #{ Time.now }"
+        OSX::NSApp.terminate(nil)
+      end
+      
+      sticky_growl HELLO_TYPE, 'Sticky', 'Hello world' do
+        puts "Clicked sticky: #{ Time.now }"
+        OSX::NSApp.terminate(nil)
+      end
+      
+      self
+    end
+  end
+end
+
+g = GrowlController.alloc.init
+OSX::NSApp.run

data/samples/growl_delegate_sample.rb

@@ -0,0 +1,36 @@
+require 'osx/cocoa'
+require File.expand_path('../../lib/growl', __FILE__)
+
+class GrowlController < OSX::NSObject
+  HELLO_TYPE = 'Hello message received'
+  
+  def init
+    if super_init
+      @g = Growl::Notifier.sharedInstance
+      @g.delegate = self
+      @g.register('GrowlSample', [HELLO_TYPE])
+      @g.notify(HELLO_TYPE, 'Sticky', 'Hello world', :sticky => true, :click_context => Time.now.to_s )
+      @g.notify(HELLO_TYPE, 'Timed out', 'Hello world', :click_context => Time.now.to_s )
+      @count = 2
+      self
+    end
+  end
+
+  def growlNotifierClicked_context(sender, context)
+    puts "Clicked: #{context}"
+    checkCount
+  end
+
+  def growlNotifierTimedOut_context(sender, context)
+    puts "Timed out: #{context}"
+    checkCount
+  end
+  
+  def checkCount
+    @count -= 1
+    OSX::NSApp.terminate(nil) if @count == 0
+  end
+end
+
+g = GrowlController.alloc.init
+OSX::NSApp.run

data/test/growl_helpers_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../test_helper', __FILE__)
+require File.expand_path('../../lib/growl_helpers', __FILE__)
+
+class Foo < OSX::NSObject
+  include Growl
+end
+
+describe "Growl, when mixed into a class" do
+  before do
+    @name = 'YourHamburgerIsReady'
+    @title = 'Your hamburger is ready for consumption!'
+    @description = 'Please pick it up at isle 4.'
+    @options = { :sticky => true, :priority => 1 }
+    
+    @object = Foo.alloc.init
+  end
+  
+  it "should define a #growl instance method" do
+    @object.should.respond_to :growl
+  end
+  
+  it "should call Growl::Notifier.sharedInstance.notify with the arguments passed to #growl" do
+    should_call_sticky_notify_with_priority_1
+    @object.growl @name, @title, @description, :sticky => true, :priority => 1
+  end
+  
+  it "should define a #sticky_growl instance method which is a shortcut method to send a sticky Growl notification" do
+    @object.should.respond_to :sticky_growl
+  end
+  
+  it "should call Growl::Notifier.sharedInstance.notify with the arguments passed to #sticky_growl and the sticky option set to true" do
+    should_call_sticky_notify_with_priority_1
+    @object.sticky_growl @name, @title, @description, :priority => 1
+  end
+  
+  private
+  
+  def should_call_sticky_notify_with_priority_1
+    Growl::Notifier.sharedInstance.expects(:notify).with(@name, @title, @description, @options)
+  end
+end

data/test/growl_test.rb

@@ -0,0 +1,254 @@
+require File.expand_path('../test_helper', __FILE__)
+require File.expand_path('../../lib/growl', __FILE__)
+
+describe 'Growl::Notifier' do
+  include GrowlNotifierSpecHelper
+  
+  before do
+    set_variables!
+    @instance.stubs(:send_registration!)
+    @instance.register @name, @notifications
+  end
+  
+  it "should be a singleton class" do
+    @instance.should.be.instance_of Growl::Notifier
+    @instance.should.be Growl::Notifier.sharedInstance
+  end
+end
+
+describe 'Growl::Notifier#register' do
+  include GrowlNotifierSpecHelper
+  
+  before do
+    set_variables!
+    @instance.stubs(:send_registration!)
+    @instance.register @name, @notifications
+  end
+  
+  it "should take the name of the application" do
+    @instance.application_name.should == @name
+  end
+  
+  it "should take an array of notifications that should be registered" do
+    @instance.notifications.should == @notifications
+  end
+  
+  it "should set the default notifications to the same as the notifications array if none is specified" do
+    @instance.default_notifications.should == @notifications
+  end
+  
+  it "should take an array of notifications that should be registered as the default notifications" do
+    @instance.register @name, @notifications, @default_notifications
+    @instance.default_notifications.should == @default_notifications
+  end
+  
+  it "should by default use the NSAppication's sharedApplication icon if none was specified" do
+    @instance.application_icon.should.be OSX::NSApplication.sharedApplication.applicationIconImage
+  end
+  
+  it "should take an optional application icon" do
+    @instance.register @name, @notifications, nil, @icon
+    @instance.application_icon.should.be @icon
+  end
+  
+  it "should register the configuration" do
+    @instance.expects(:send_registration!)
+    @instance.register @name, @notifications
+  end
+end
+
+describe 'Growl::Notifier#send_registration!' do
+  include GrowlNotifierSpecHelper
+  
+  before do
+    set_variables!
+    @tiff = mock('TIFFRepresentation')
+    @icon.stubs(:TIFFRepresentation).returns(@tiff)
+  end
+  
+  it "should register itself with Growl" do
+    pid = 54231
+    @instance.stubs(:pid).returns(pid)
+    
+    @instance.expects(:add_observer).with('onReady:', "Lend Me Some Sugar; I Am Your Neighbor!", false)
+    @instance.expects(:add_observer).with('onClicked:', "GrowlClicked!", true)
+    @instance.expects(:add_observer).with('onTimeout:', "GrowlTimedOut!", true)
+    
+    dict = {
+      :ApplicationName => @name,
+      :ApplicationIcon => @tiff,
+      :AllNotifications => @notifications,
+      :DefaultNotifications => @default_notifications
+    }
+    
+    @center.expects(:objc_send).with(
+      :postNotificationName, :GrowlApplicationRegistrationNotification,
+                    :object, nil,
+                  :userInfo, dict,
+        :deliverImmediately, true
+    )
+    
+    @instance.register @name, @notifications, @default_notifications, @icon
+  end
+end
+
+describe "Growl::Notifier.sharedInstance" do
+  include GrowlNotifierSpecHelper
+  
+  before do
+    set_variables!
+    
+    @pid = 54231
+    OSX::NSProcessInfo.processInfo.stubs(:processIdentifier).returns(@pid)
+  end
+  
+  it "should return the applications PID" do
+    @instance.send(:pid).should.be @pid
+  end
+  
+  it "should be able to easily add observers to the NSDistributedNotificationCenter" do
+    @center.expects(:addObserver_selector_name_object).with(@instance, 'selector:', "name", nil)
+    @instance.send(:add_observer, 'selector:', 'name', false)
+    
+    @center.expects(:addObserver_selector_name_object).with(@instance, 'selector:', "#{@name}-#{@pid}-name", nil)
+    @instance.send(:add_observer, 'selector:', 'name', true)
+  end
+  
+  it "should send a notification to Growl" do
+    another_icon = mock('Another icon')
+    another_icons_tiff_rep = mock('Another icons tiff representation')
+    another_icon.stubs(:TIFFRepresentation).returns(another_icons_tiff_rep)
+    
+    dict = {
+      :ApplicationName => @name,
+      :ApplicationPID => @pid,
+      :NotificationName => @notifications.first,
+      :NotificationTitle => 'title',
+      :NotificationDescription => 'description',
+      :NotificationPriority => 1,
+      :NotificationIcon => another_icons_tiff_rep,
+      :NotificationSticky => 1,
+      :NotificationClickContext => { :user_click_context => 'foo' }
+    }
+    
+    @center.expects(:postNotificationName_object_userInfo_deliverImmediately).with(:GrowlNotification, nil, dict, true)
+    
+    @instance.notify(@notifications.first, 'title', 'description', :sticky => true, :priority => 1, :icon => another_icon, :click_context => 'foo')
+  end
+  
+  it "should not require all options to be specified when sending a notification to Growl" do
+    dict = {
+      :ApplicationName => @name,
+      :ApplicationPID => @pid,
+      :NotificationName => @notifications.first,
+      :NotificationTitle => 'title',
+      :NotificationDescription => 'description',
+      :NotificationPriority => 0
+    }
+    
+    @center.expects(:postNotificationName_object_userInfo_deliverImmediately).with(:GrowlNotification, nil, dict, true)
+    @instance.notify(@notifications.first, 'title', 'description')
+  end
+  
+  it "should take a symbol instead of an integer to specify the priority level when sending a notification to Growl" do
+    priority_table = { :very_low => -2, :moderate => -1, :normal => 0, :high => 1, :emergency => 2 }
+    
+    priority_table.each do |key, value|
+      @center.expects(:postNotificationName_object_userInfo_deliverImmediately).with do |name, object, info, immediately|
+        info[:NotificationPriority] == value
+      end
+      
+      @instance.notify(@notifications.first, 'title', 'description', :priority => key)
+    end
+  end
+  
+  it "should add a callback to the callbacks if a block is given to #notify" do
+    callback = proc { message_from_callback }
+    @center.expects(:postNotificationName_object_userInfo_deliverImmediately).with do |name, object, info, immediately|
+      info[:NotificationClickContext] = { :callback_object_id => callback.object_id, :user_click_context => 'foo' }
+    end
+    
+    @instance.notify(@notifications.first, 'title', 'description', { :click_context => 'foo' }, &callback)
+    
+    @instance.instance_variable_get(:@callbacks)[callback.object_id].should.be callback
+  end
+  
+  it "should call a callback handler if the notification that it belongs to is clicked and then remove the callback" do
+    callback = nil
+    @instance.instance_eval do
+      callback = proc { message_from_callback }
+    end
+    @instance.notify(@notifications.first, 'title', 'description', &callback)
+    
+    @instance.expects(:message_from_callback)
+    @instance.onClicked(stubbed_notification(:callback_object_id => callback.object_id.to_s.to_ns))
+    @instance.instance_variable_get(:@callbacks)[callback.object_id].should.be nil
+  end
+  
+  it "should send a message to the delegate if a notification was clicked with the specified context" do
+    notification = stubbed_notification(:user_click_context => 'foo')
+    assign_delegate.expects(:growlNotifierClicked_context).with(@instance, 'foo')
+    @instance.onClicked(notification)
+  end
+  
+  it "should send a message to the delegate if a notification was clicked with nil as the context if none was specified" do
+    notification = stubbed_notification
+    assign_delegate.expects(:growlNotifierClicked_context).with(@instance, nil)
+    @instance.onClicked(notification)
+  end
+  
+  it "should not send a message to the delegate if a notification was clicked but the delegate doesn't respond to the delegate method" do
+    assign_delegate
+    @instance.onClicked(stubbed_notification)
+  end
+  
+  it "should remove a callback handler if the notification that it belongs to times out" do
+    callback = proc {}
+    notification = stubbed_notification(:callback_object_id => callback.object_id.to_s.to_ns)
+    
+    @instance.notify(@notifications.first, 'title', 'description', &callback)
+    @instance.delegate = nil
+    
+    callback.expects(:call).times(0)
+    @instance.onTimeout(notification)
+    @instance.instance_variable_get(:@callbacks)[callback.object_id].should.be nil
+  end
+  
+  it "should send a message to the delegate if a notification times out with the specified context" do
+    notification = stubbed_notification(:user_click_context => 'foo')
+    assign_delegate.expects(:growlNotifierTimedOut_context).with(@instance, 'foo')
+    
+    @instance.onTimeout(notification)
+  end
+  
+  it "should send a message to the delegate if a notification times out with nil as the context in none was specified" do
+    notification = stubbed_notification
+    assign_delegate.expects(:growlNotifierTimedOut_context).with(@instance, nil)
+    
+    @instance.onTimeout(notification)
+  end
+  
+  it "should not send a message to the delegate if a notification times out but the delegate doesn't respond to the delegate method" do
+    assign_delegate
+    @instance.onTimeout(stubbed_notification)
+  end
+  
+  it "should resend the registration data to Growl if Growl was restarted for some reason" do
+    @instance.expects(:send_registration!)
+    @instance.onReady(nil)
+  end
+  
+  private
+  
+  def assign_delegate
+    delegate = mock('delegate')
+    @instance.delegate = delegate
+    delegate
+  end
+  
+  def stubbed_notification(options = {})
+    notification = stub('timeout notification')
+    notification.stubs(:userInfo).returns("ClickedContext" => options.to_ns)
+    notification
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,23 @@
+require "rubygems"
+require "test/unit"
+require "test/spec"
+require "mocha"
+require 'osx/cocoa'
+
+def OSX._ignore_ns_override; true; end
+
+$: << File.expand_path('../../lib', __FILE__)
+
+module GrowlNotifierSpecHelper
+  def set_variables!
+    @instance = Growl::Notifier.sharedInstance
+    @name = 'GrowlerApp'
+    @icon = mock('PrettyIcon')
+    @notifications = ['YourHamburgerIsReady', 'OhSomeoneElseAteIt']
+    @default_notifications = ['ADefaultNotification', *@notifications]
+    
+    @center = mock('NSDistributedNotificationCenter')
+    @center.stubs(:postNotificationName_object_userInfo_deliverImmediately)
+    OSX::NSDistributedNotificationCenter.stubs(:defaultCenter).returns(@center)
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: growlnotifier
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Satoshi Nakagawa
+- Eloy Duran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-04 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
+description: A ruby library which allows you to send Growl notifications.
+email: 
+- psychs@limechat.net
+- e.duran@superalloy.nl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+- README.txt
+files: 
+- Manifest.txt
+- README.txt
+- Rakefile
+- LICENSE
+- lib/growl.rb
+- lib/growl_helpers.rb
+- samples/growl_block_sample.rb
+- samples/growl_delegate_sample.rb
+- test/growl_test.rb
+- test/growl_helpers_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://growlnotifier.rubyforge.org/
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: growlnotifier
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Growl::Notifier is a OSX RubyCocoa class that allows your application to post notifications to the Growl daemon.
+test_files: 
+- test/test_helper.rb