groem 0.0.4

data/lib/groem/notification.rb

@@ -0,0 +1,140 @@
+require 'eventmachine'
+require 'uuidtools'
+
+module Groem
+
+  class Notification < Struct.new(:environment,
+                                  :application_name,
+                                  :name,
+                                  :display_name,
+                                  :enabled,
+                                  :title,
+                                  :text,
+                                  :sticky,
+                                  :priority,
+                                  :coalescing_id,
+                                  :headers
+                                 )
+    include Groem::Marshal::Request
+    
+    DEFAULT_ENV = {'protocol' => 'GNTP', 'version' => '1.0',
+                   'request_method' => 'NOTIFY', 'encryption_id' => 'NONE'
+                  }
+    
+    def initialize(name, *args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      title = args.shift
+      self.environment, self.headers, @callback = {}, {}, {}
+      self.environment = DEFAULT_ENV.merge(opts.delete(:environment) || {})
+      self.name = name.to_s if name
+      self.title = title.to_s if title
+      self.enabled = 'True'
+      self.headers = opts.delete(:headers) || {}
+      opts.each_pair do |opt, val| 
+        if self.respond_to?(:"#{opt}=")   
+          self.__send__ :"#{opt}=", val.to_s
+        else
+          header(opt, val.to_s)
+        end
+      end
+      reset!
+    end
+    
+    def [](key)
+      to_request[key]
+    end
+    
+    def reset!
+      @to_request = nil
+      self
+    end
+    
+    def reset_callback!
+      @callback = {}
+    end
+
+    def dup
+      attrs = {}; self.each_pair {|k, v| attrs[k] = v.dup if v}
+      n = self.class.new(self.name, attrs)
+      n.callback(:context => callback_context, 
+                 :type => callback_type,
+                 :target => callback_target) if @callback
+      n
+    end
+    
+    def header key, value
+      reset!
+      self.headers[growlify_key(key)] = value
+    end
+
+    def icon(uri_or_file)
+      # TODO if not uri
+      reset!
+      header GNTP_NOTIFICATION_ICON_KEY, uri_or_file
+    end
+    
+    # Note defaults name and type to notification name
+    def callback *args
+      opts = ((Hash === args.last) ? args.pop : {})
+      name = args.shift || opts[:context] || self.name
+      type = opts[:type] || self.name
+      target = opts[:target]
+      reset!
+      reset_callback!
+      @callback[GNTP_NOTIFICATION_CALLBACK_CONTEXT_KEY] = name if name
+      @callback[GNTP_NOTIFICATION_CALLBACK_CONTEXT_TYPE_KEY] = type if type
+      @callback[GNTP_NOTIFICATION_CALLBACK_TARGET_KEY] = target if target
+      @callback
+    end
+    
+    def callback_context
+      @callback[GNTP_NOTIFICATION_CALLBACK_CONTEXT_KEY]
+    end
+    
+    def callback_type
+      @callback[GNTP_NOTIFICATION_CALLBACK_CONTEXT_TYPE_KEY]
+    end
+    alias_method :callback_context_type, :callback_type
+    
+    def callback_target
+      @callback[GNTP_NOTIFICATION_CALLBACK_TARGET_KEY]
+    end
+    
+    def to_register
+      %w{display_name enabled}.inject({}) do |memo, attr|
+        if val = self.__send__(:"#{attr}")
+          memo["Notification-#{growlify_key(attr)}"] = val
+        end
+        memo
+      end.merge(self.headers)
+    end
+    
+    def to_notify
+      %w{name title text sticky priority coalescing_id}.inject({}) do |memo, attr|
+        if val = self.__send__(:"#{attr}")
+          memo["Notification-#{growlify_key(attr)}"] = val
+        end
+        memo
+      end.merge({GNTP_APPLICATION_NAME_KEY => self.application_name}).
+          merge({GNTP_NOTIFICATION_ID_KEY => unique_id}).
+          merge(@callback).
+          merge(self.headers)
+    end
+    
+    def to_request
+      @to_request ||= \
+        {'environment' => environment,
+         'headers' => to_notify,
+         'notifications' => {}
+        }
+    end
+    
+   protected 
+    
+    def unique_id
+      UUIDTools::UUID.timestamp_create.to_s
+    end
+    
+  end
+
+end

data/lib/groem/response.rb

@@ -0,0 +1,86 @@
+require 'forwardable'
+
+module Groem
+  class Response < Struct.new(:status,
+                              :method,
+                              :action,
+                              :notification_id,
+                              :context,
+                              :context_type,
+                              :callback_result,
+                              :headers)
+    include Groem::Marshal::Response
+    extend Forwardable
+    
+    def_delegator :@raw, :[]
+    
+    def initialize(resp)
+      @raw = resp
+      self.status = resp[0]
+      self.headers = resp[1]
+      self.action = resp[1][GNTP_RESPONSE_ACTION_KEY]
+      self.notification_id = resp[1][GNTP_NOTIFICATION_ID_KEY]
+      self.context = resp[2][GNTP_NOTIFICATION_CALLBACK_CONTEXT_KEY]
+      self.context_type = resp[2][GNTP_NOTIFICATION_CALLBACK_CONTEXT_TYPE_KEY]
+      self.callback_result = resp[2][GNTP_NOTIFICATION_CALLBACK_RESULT_KEY]
+      self.method = if self.status.to_i == 0
+                      if self.callback_result
+                        GNTP_CALLBACK_RESPONSE
+                      else
+                        GNTP_OK_RESPONSE
+                      end
+                    else
+                      GNTP_ERROR_RESPONSE
+                    end
+    end
+    
+    def callback_route
+      [self.callback_result, self.context, self.context_type]
+    end
+    
+    def to_register? &blk
+      yield_and_return_if self.action == GNTP_REGISTER_METHOD, &blk
+    end
+    
+    def to_notify? &blk
+      yield_and_return_if self.action == GNTP_NOTIFY_METHOD, &blk
+    end
+    
+    def ok? &blk
+      yield_and_return_if self.method == GNTP_OK_RESPONSE, &blk
+    end
+    
+    def callback? &blk
+      yield_and_return_if self.method == GNTP_CALLBACK_RESPONSE, &blk
+    end
+    
+    def error?(code=nil, &blk)
+      yield_and_return_if (self.method == GNTP_ERROR_RESPONSE  && \
+                           code.nil? || self.status == code), &blk
+    end
+    
+    def clicked? &blk
+      yield_and_return_if self.callback_result == GNTP_CLICK_CALLBACK_RESULT, &blk
+    end
+    
+    def closed? &blk
+      yield_and_return_if self.callback_result == GNTP_CLOSE_CALLBACK_RESULT, &blk
+    end
+    
+    def timedout? &blk
+      yield_and_return_if self.callback_result == GNTP_TIMEDOUT_CALLBACK_RESULT, &blk
+    end
+    
+    alias_method :click?, :clicked?
+    alias_method :close?, :closed?
+    alias_method :timeout?, :timedout?
+    
+    protected
+    
+    def yield_and_return_if(cond)
+      yield if block_given? && cond
+      cond
+    end
+    
+  end
+end

data/lib/groem/route.rb

@@ -0,0 +1,37 @@
+
+module Groem
+  class Route
+
+    class << self
+      def parse action, *path
+        [action] + Array.new(2).fill {|i| path[i] }
+      end
+    
+      def matches? pattern, parts
+        parts = [parts] unless Array === parts
+        pattern.zip(parts).all? do |exp, act|
+          exp.nil? || exp == act
+        end
+      end
+      
+    end
+    
+    attr_reader :pattern
+    
+    def initialize action, *path
+      path = path.flatten
+      @pattern = self.class.parse action, *path
+    end
+      
+    def matches?(*args)
+      self.class.matches?(pattern, args.flatten)
+    end
+        
+
+    # sort nil parts after named parts (unless named parts begin with ~)
+    def <=>(other)
+      pattern.map {|it| it || '~'} <=> other.pattern.map {|it| it || '~'}
+    end
+    
+  end
+end

data/lib/groem/version.rb

@@ -0,0 +1,3 @@
+module Groem
+  VERSION = '0.0.4'
+end

data/spec/functional/app_notify_adhoc_spec.rb

@@ -0,0 +1,73 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+
+describe 'Groem::App #notify with ad-hoc callback' do
+
+  before do
+    @p_svr = DummyServerHelper.fork_server(:callback => ['CLICK', 2])
+    Groem::Client.response_class = MarshalHelper.dummy_response_class
+    @subject = Groem::App.new('test', :port => DummyServerHelper::DEFAULT_PORT)
+  end
+  
+  after do
+    DummyServerHelper.kill_server(@p_svr)
+  end    
+
+  it 'should receive CLICK callback matching ad-hoc callback spec' do
+    ok_count = 0
+    cb_count = 0
+    
+    app = @subject
+    app.register do
+      notification 'Foo' do |n|
+        n.display_name = 'Hoo'
+        n.callback 'First', :type => '1'
+      end
+    end
+   
+    app.when_click :type => '2' do |resp|
+      cb_count += 1
+    end
+        
+    app.when_click 'Second' do |resp|
+      cb_count += 1
+    end
+    
+    app.when_click 'First' do |resp|
+      flunk 'Expected callback context \'Second\', got \'First\''
+    end
+    
+    app.when_click :type => '1' do |resp|
+      flunk 'Expected callback context type \'2\', got \'1\''
+    end
+        
+    app.notify('Foo', :callback => {:context => 'Second', :type => '2'})
+
+    cb_count.must_equal 2
+  end
+
+  it 'should trigger callback with ad-hoc state, but not change state of registered callback' do
+  
+    app = @subject
+    app.register do
+      notification 'Foo' do |n|
+        n.display_name = 'Hoo'
+        n.callback 'First', :type => '1'
+      end
+    end
+    
+    app.when_click do |resp|
+      puts resp[0..2].inspect
+      resp.context.must_equal 'Second'
+      resp.context_type.must_equal '2'
+    end
+    
+    app.notify('Foo', :display_name => 'Who',
+                      :callback => {:context => 'Second', :type => '2'})
+    
+    app.notifications['Foo'].display_name.must_equal 'Hoo'
+    app.notifications['Foo'].callback_context.must_equal 'First'
+    app.notifications['Foo'].callback_type.must_equal '1'
+    
+  end
+  
+end

data/spec/functional/app_notify_spec.rb

@@ -0,0 +1,390 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+ 
+describe 'Groem::App #notify without callbacks' do
+
+  describe 'with one notification' do
+  
+    before do
+      @p_svr = DummyServerHelper.fork_server(:notify => '-OK')
+      Groem::Client.response_class = MarshalHelper.dummy_response_class
+      @subject = Groem::App.new('test', :port => DummyServerHelper::DEFAULT_PORT)
+    end
+    
+    after do
+      DummyServerHelper.kill_server(@p_svr)
+    end
+
+    it 'should receive back one OK response from notify' do
+      count = 0
+      
+      @subject.register do
+        notification 'hello' do end
+      end
+      
+      @subject.notify('hello') do |resp|
+        count += 1
+        resp[0].to_i.must_equal 0
+        resp[2].must_be_empty
+        count.must_equal 1
+      end
+      
+    end
+
+    it 'should return OK response from notify' do
+      
+      @subject.register do
+        notification 'hello' do end
+      end
+      
+      ret = @subject.notify('hello')
+      ret.class.must_be_same_as Groem::Response
+      ret[0].to_i.must_equal 0
+      ret[2].must_be_empty
+      
+    end
+
+  end
+ 
+  describe 'when notification hasnt been specified' do
+
+    before do
+      @p_svr = DummyServerHelper.fork_server(:notify => '-OK')
+      Groem::Client.response_class = MarshalHelper.dummy_response_class
+      @subject = Groem::App.new('test', :port => DummyServerHelper::DEFAULT_PORT)
+    end
+    
+    after do
+      DummyServerHelper.kill_server(@p_svr)
+    end
+  
+    it 'should return nil' do
+      
+      @subject.register do
+        notification 'hello' do end
+      end
+      
+      @subject.notify('goodbye') do end.must_be_nil
+      
+    end
+    
+  end
+   
+end
+
+module AppNotifyCallbacksHelper
+
+
+  def should_receive_ok_and_callback(app, rslt, timeout, opts = {})
+    click_name = opts[:click] || 'CLICK'
+    close_name = opts[:close] || 'CLOSE'
+    timedout_name = opts[:timedout] || 'TIMEDOUT'
+    ok_count = 0
+    click_count = 0
+    close_count = 0
+    timedout_count = 0
+    
+    EM.run {
+      app.register do
+        notification 'Foo' do |n|
+          n.callback 'You', :type => 'shiny'
+        end
+      end
+     
+      app.when_callback click_name do |resp|
+        puts "App received callback: #{resp[2]['Notification-Callback-Result']}"
+        click_count += 1
+        ['CLICK', 'CLICKED'].must_include resp[2]['Notification-Callback-Result']
+      end
+      
+      app.when_callback close_name do |resp|
+        puts "App received callback: #{resp[2]['Notification-Callback-Result']}"
+        close_count += 1
+        ['CLOSE', 'CLOSED'].must_include resp[2]['Notification-Callback-Result']
+      end
+      
+      app.when_callback timedout_name do |resp|
+        puts "App received callback: #{resp[2]['Notification-Callback-Result']}"
+        timedout_count += 1
+        ['TIMEDOUT', 'TIMEOUT'].must_include resp[2]['Notification-Callback-Result']
+      end
+      
+      app.notify('Foo') do |resp|
+        ok_count += 1 if resp[0].to_i == 0
+        resp[0].to_i.must_equal 0
+      end
+     
+      EM.add_timer(timeout + 1) {
+        ok_count.must_equal 1
+        case rslt
+        when 'CLICK'
+          click_count.must_equal 1
+          close_count.must_equal 0
+          timedout_count.must_equal 0
+        when 'CLOSE'
+          click_count.must_equal 0
+          close_count.must_equal 1
+          timedout_count.must_equal 0
+        when 'TIMEDOUT'
+          click_count.must_equal 0
+          close_count.must_equal 0
+          timedout_count.must_equal 1
+        end
+        EM.stop
+      }
+      
+    }
+  end
+
+  def should_receive_ok_and_callback_outside_reactor(app, rslt, timeout, opts = {})
+    click_name = opts[:click] || 'CLICK'
+    close_name = opts[:close] || 'CLOSE'
+    timedout_name = opts[:timedout] || 'TIMEDOUT'
+    ok_count = 0
+    click_count = 0
+    close_count = 0
+    timedout_count = 0
+    
+    app.register do
+      notification 'Foo' do |n|
+        n.callback 'You', :type => 'shiny'
+      end
+    end
+   
+    app.when_callback click_name do |resp|
+      puts "App received callback: #{resp[2]['Notification-Callback-Result']}"
+      click_count += 1
+      ['CLICK', 'CLICKED'].must_include resp[2]['Notification-Callback-Result']
+    end
+    
+    app.when_callback close_name do |resp|
+      puts "App received callback: #{resp[2]['Notification-Callback-Result']}"
+      close_count += 1
+      ['CLOSE', 'CLOSED'].must_include resp[2]['Notification-Callback-Result']
+    end
+    
+    app.when_callback timedout_name do |resp|
+      puts "App received callback: #{resp[2]['Notification-Callback-Result']}"
+      timedout_count += 1
+      ['TIMEDOUT', 'TIMEOUT'].must_include resp[2]['Notification-Callback-Result']
+    end
+    
+    app.notify('Foo') do |resp|
+      ok_count += 1 if resp[0].to_i == 0
+      resp[0].to_i.must_equal 0
+    end
+  
+    ok_count.must_equal 1
+    case rslt
+    when 'CLICK'
+      click_count.must_equal 1
+      close_count.must_equal 0
+      timedout_count.must_equal 0
+    when 'CLOSE'
+      click_count.must_equal 0
+      close_count.must_equal 1
+      timedout_count.must_equal 0
+    when 'TIMEDOUT'
+      click_count.must_equal 0
+      close_count.must_equal 0
+      timedout_count.must_equal 1
+    end
+    
+  end
+
+  
+  def should_return_ok_response(app)
+
+    app.register do
+      notification 'Foo' do |n|
+        n.callback 'You', :type => 'shiny'
+      end
+    end
+  
+    ret = app.notify('Foo')
+    ret.class.must_be_same_as Groem::Response
+    ret[0].to_i.must_equal 0
+    ret[2].must_be_empty
+  end
+  
+  
+end
+
+
+describe 'Groem::App #notify with simple callbacks' do
+
+
+  describe 'when CLICK callback returned' do
+    include AppNotifyCallbacksHelper
+    
+    before do
+      @p_svr = DummyServerHelper.fork_server(:callback => ['CLICK', 2])
+      Groem::Client.response_class = MarshalHelper.dummy_response_class
+      @subject = Groem::App.new('test', :port => DummyServerHelper::DEFAULT_PORT)
+    end
+    
+    after do
+      DummyServerHelper.kill_server(@p_svr)
+    end    
+    
+    it 'should receive ok and CLICK callback' do
+      should_receive_ok_and_callback(@subject, 'CLICK', 2)
+    end
+
+    it 'should receive ok and CLICK callback outside reactor' do
+      should_receive_ok_and_callback_outside_reactor(@subject, 'CLICK', 2)
+    end
+    
+    it 'should receive ok and CLICK callback using symbolized actions' do
+      should_receive_ok_and_callback(@subject, 'CLICK', 2, 
+                                     :click => :click, 
+                                     :close => :closed, 
+                                     :timedout => :timedout)
+    end
+    
+    it 'should receive ok and CLICK callback with alternate action names' do
+      should_receive_ok_and_callback(@subject, 'CLICK', 2, 
+                                     :click => 'CLICKED', 
+                                     :close => 'CLOSED', 
+                                     :timedout => 'TIMEOUT')
+    end
+
+    it 'should return ok response' do
+      should_return_ok_response(@subject)
+    end
+    
+  end
+  
+  describe 'when CLOSE callback returned' do
+    include AppNotifyCallbacksHelper
+    
+    before do
+      @p_svr = DummyServerHelper.fork_server(:callback => ['CLOSE', 2])
+      Groem::Client.response_class = MarshalHelper.dummy_response_class
+      @subject = Groem::App.new('test', :port => DummyServerHelper::DEFAULT_PORT)
+    end
+    
+    after do
+      DummyServerHelper.kill_server(@p_svr)
+    end    
+    
+    it 'should receive ok and CLOSE callback' do
+      should_receive_ok_and_callback(@subject, 'CLOSE', 2)
+    end
+    
+    it 'should receive ok and CLOSE callback using symbolized actions' do
+      should_receive_ok_and_callback(@subject, 'CLOSE', 2, 
+                                     :click => :click, 
+                                     :close => :closed, 
+                                     :timedout => :timedout)
+    end
+    
+    it 'should receive ok and CLOSE callback with alternate action names' do
+      should_receive_ok_and_callback(@subject, 'CLOSE', 2, 
+                                     :click => 'CLICKED', 
+                                     :close => 'CLOSED', 
+                                     :timedout => 'TIMEOUT')
+    end
+
+    it 'should return ok response' do
+      should_return_ok_response(@subject)
+    end
+
+  end
+  
+  describe 'when TIMEDOUT callback returned' do
+    include AppNotifyCallbacksHelper
+    
+    before do
+      @p_svr = DummyServerHelper.fork_server(:callback => ['TIMEDOUT', 2])
+      Groem::Client.response_class = MarshalHelper.dummy_response_class
+      @subject = Groem::App.new('test', :port => DummyServerHelper::DEFAULT_PORT)
+    end
+    
+    after do
+      DummyServerHelper.kill_server(@p_svr)
+    end    
+    
+    it 'should receive ok and TIMEDOUT callback' do
+      should_receive_ok_and_callback(@subject, 'TIMEDOUT', 2)
+    end
+      
+    it 'should receive ok and TIMEDOUT callback using symbolized actions' do
+      should_receive_ok_and_callback(@subject, 'TIMEDOUT', 2, 
+                                     :click => :click, 
+                                     :close => :closed, 
+                                     :timedout => :timedout)
+    end
+    
+    it 'should receive ok and TIMEDOUT callback with alternate action names' do
+      should_receive_ok_and_callback(@subject, 'TIMEDOUT', 2, 
+                                     :click => 'CLICKED', 
+                                     :close => 'CLOSED', 
+                                     :timedout => 'TIMEOUT')
+    end
+
+    it 'should return ok response' do
+      should_return_ok_response(@subject)
+    end
+    
+  end
+  
+end
+
+
+describe 'Groem::App #notify with routed callbacks' do
+
+    before do
+      @p_svr = DummyServerHelper.fork_server(:callback => ['CLICK', 2])
+      Groem::Client.response_class = MarshalHelper.dummy_response_class
+      @subject = Groem::App.new('test', :port => DummyServerHelper::DEFAULT_PORT)
+    end
+    
+    after do
+      DummyServerHelper.kill_server(@p_svr)
+    end    
+    
+    it 'should receive ok and CLICK callback matching multiple routes' do
+      ok_count = 0
+      cb_count = 0
+      
+      app = @subject
+      app.register do
+        notification 'Foo' do |n|
+          n.callback 'You', :type => 'shiny'
+        end
+      end
+     
+      app.when_click 'You' do |resp|
+        cb_count.must_equal 1
+        cb_count += 1
+      end
+      
+      app.when_click :context => 'You', :type => 'shiny' do |resp|
+        cb_count.must_equal 0
+        cb_count += 1
+      end
+      
+      app.when_click do |resp|
+        cb_count.must_equal 3
+        cb_count += 1
+      end
+      
+      app.when_click :type => 'shiny' do |resp|
+        cb_count.must_equal 2
+        cb_count += 1
+      end
+      
+      app.notify('Foo') do |resp|
+        ok_count += 1 if resp[0].to_i == 0
+        resp[0].to_i.must_equal 0
+      end
+
+      ok_count.must_equal 1
+      cb_count.must_equal 4
+    end
+
+    
+end
+
+
+