spire_io 1.0.0 → 1.2

data/lib/spire/api.rb

@@ -10,7 +10,10 @@ require "spire/api/session"
 require "spire/api/account"
 require "spire/api/channel"
 require "spire/api/subscription"
-require "spire/api/message"
+require "spire/api/event"
+require "spire/api/application"
+require "spire/api/member"
+require "spire/api/notification"
 
 class Spire
 
@@ -28,10 +31,6 @@ class Spire
       @url = url
     end
 
-    def inspect
-      "#<Spire::API:0x#{object_id.to_s(16)} @url=#{@url.dump}>"
-    end
-
     define_request(:discover) do
       {
         :method => :get,
@@ -71,7 +70,8 @@ class Spire
         :body => {
           :email => info[:email],
           :password => info[:password],
-          :password_confirmation => info[:password_confirmation]
+          :password_confirmation => info[:password_confirmation],
+          :email_opt_in => info[:email_opt_in]
         }.to_json,
         :headers => { 
           "Accept" => mediaType("session"),
@@ -99,6 +99,17 @@ class Spire
       }
     end
 
+    define_request(:get_application) do |app_key|
+      {
+        :method => :get,
+        :url => @description["resources"]["applications"]["url"],
+        :query => {:application_key => app_key},
+        :headers => {
+          "Accept" => mediaType("applications"),
+          "Content-Type" => mediaType("applications")
+        }
+      }
+    end
 
     def discover
       response = request(:discover)
@@ -146,6 +157,16 @@ class Spire
       response
     end
 
+    # Gets an application resource from a key without requiring any authentication
+    # @param [String] application_key The application key
+    def get_application(application_key)
+      response = request(:get_application, application_key)
+      if response.status != 200
+        raise "Error attempting to retrieve application (#{response.status}) #{response.body}"
+      end
+      API::Application.new(self, response.data)
+    end
+
     # Returns a billing object than contains a list of all the plans available
     # @param [String] info optional object description
     # @return [Billing]

data/lib/spire/api/application.rb

@@ -0,0 +1,325 @@
+require 'base64'
+class Spire
+  class API
+
+    class Application < Resource
+      attr_reader :resources
+
+      def resource_name
+        "application"
+      end
+
+      def initialize(spire, data)
+        super
+        @resources = data["resources"]
+      end
+
+      #Channels
+      define_request(:create_channel) do |name, message_limit, message_ttl|
+        collection = @resources["channels"]
+        capability = collection["capabilities"]["create"]
+        url = collection["url"]
+
+        body = {
+          :name => name,
+          :message_limit => message_limit,
+          :message_ttl => message_ttl
+        }.to_json
+        {
+          :method => :post,
+          :url => url,
+          :body => body,
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("channel"),
+            "Content-Type" => @spire.mediaType("channel")
+          }
+        }
+      end
+
+      define_request(:channels) do
+        collection = @resources["channels"]
+        capability = collection["capabilities"]["all"]
+        url = collection["url"]
+        {
+          :method => :get,
+          :url => url,
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("channels"),
+          }
+        }
+      end
+
+      define_request(:channel_by_name) do |name|
+        collection = @resources["channels"]
+        capability = collection["capabilities"]["get_by_name"]
+        url = collection["url"]
+        request = {
+          :method => :get,
+          :url => url,
+          :query => {:name => name},
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("channels"),
+          }
+        }
+      end
+
+      #Subscriptions
+      define_request(:subscriptions) do
+        collection = @resources["subscriptions"]
+        capability = collection["capabilities"]["all"]
+        url = collection["url"]
+        {
+          :method => :get,
+          :url => url,
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("subscriptions"),
+          }
+        }
+      end
+
+      define_request(:create_subscription) do |subscription_name, channel_urls|
+        collection = @resources["subscriptions"]
+        capability = collection["capabilities"]["create"]
+        url = collection["url"]
+        {
+          :method => :post,
+          :url => url,
+          :body => {
+            :channels => channel_urls,
+            :name => subscription_name
+          }.to_json,
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("subscription"),
+            "Content-Type" => @spire.mediaType("subscription")
+          }
+        }
+      end
+
+      define_request(:subscription_by_name) do |name|
+        collection = @resources["subscriptions"]
+        capability = collection["capabilities"]["get_by_name"]
+        url = collection["url"]
+        request = {
+          :method => :get,
+          :url => url,
+          :query => {:name => name},
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("subscriptions"),
+          }
+        }
+      end
+
+      #Members
+      define_request(:create_member) do |data|
+        collection = @resources["members"]
+        capability = collection["capabilities"]["create"]
+        url = collection["url"]
+        {
+          :method => :post,
+          :url => url,
+          :body => data.to_json,
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("member"),
+            "Content-Type" => @spire.mediaType("member")
+          }
+        }
+      end
+
+      define_request(:members) do
+        collection = @resources["members"]
+        capability = collection["capabilities"]["all"]
+        url = collection["url"]
+        {
+          :method => :get,
+          :url => url,
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("members"),
+          }
+        }
+      end
+
+      define_request(:member_by_login) do |login|
+        collection = @resources["members"]
+        capability = collection["capabilities"]["get_by_login"]
+        url = collection["url"]
+        request = {
+          :method => :get,
+          :url => url,
+          :query => {:login => login},
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("member"),
+          }
+        }
+      end
+
+      define_request(:authenticate_with_post) do |data|
+        collection = @resources["authentication"]
+        url = collection["url"]
+        request = {
+          :method => :post,
+          :url => url,
+          :body => data.to_json,
+          :headers => {
+            "Accept" => @spire.mediaType("member"),
+          }
+        }
+      end
+
+      define_request(:authenticate) do |data|
+        collection = @resources["members"]
+        url = "#{collection["url"]}?login=#{data[:login]}"
+        auth = Base64.encode64("#{data[:login]}:#{data[:password]}").gsub("\n", '')
+        request = {
+          :method => :get,
+          :url => url,
+          :headers => {
+            "Accept" => @spire.mediaType("member"),
+            "Authorization" => "Basic #{auth}"
+          }
+        }
+      end
+
+      #Authenticates with the application using basic auth
+      def authenticate(login, password)
+        response = request(:authenticate, {:login => login, :password => password})
+        unless response.status == 200
+          raise "Error authenticating for application #{self.name}: (#{response.status}) #{response.body}"
+        end
+        API::Member.new(@spire, response.data)
+      end
+
+      #Alternative application authentication, without using basic auth
+      def authenticate_with_post(login, password)
+        response = request(:authenticate_with_post, {:login => login, :password => password})
+        unless response.status == 201
+          raise "Error authenticating for application #{self.name}: (#{response.status}) #{response.body}"
+        end
+        API::Member.new(@spire, response.data)
+      end
+
+      def create_member(member_data)
+        response = request(:create_member, member_data)
+        unless response.status == 201
+          raise "Error creating member for application #{self.name}: (#{response.status}) #{response.body}"
+        end
+        API::Member.new(@spire, response.data)
+      end
+      
+      def members
+        @members || members!
+      end
+
+      def members!
+        response = request(:members)
+        unless response.status == 200
+          raise "Error getting members for application #{self.name}: (#{response.status}) #{response.body}"
+        end
+        @members = {}
+        response.data.each do |login, properties|
+          @members[login] = API::Member.new(@spire, properties)
+        end
+        @members
+      end
+
+      def get_member(member_login)
+        response = request(:member_by_login, member_login)
+        unless response.status == 200
+          raise "Error finding member with login #{member_login}: (#{response.status}) #{response.body}"
+        end
+        properties = response.data[member_login]
+        member = API::Member.new(@spire, properties)
+        @members[member_login] = member if @members.is_a?(Hash)
+        member
+      end
+      
+      def create_channel(name, options={})
+        message_limit = options[:message_limit]
+        message_ttl = options[:message_ttl]
+        response = request(:create_channel, name, message_limit, message_ttl)
+        unless response.status == 201
+          raise "Error creating Channel: (#{response.status}) #{response.body}"
+        end
+        properties = response.data
+        channels[name] = API::Channel.new(@spire, properties)
+      end
+
+      def create_subscription(subscription_name, channel_names)
+        channel_urls = channel_names.flatten.map { |name| self.channels[name].url rescue nil }.compact
+        response = request(:create_subscription, subscription_name, channel_urls)
+        unless response.status == 201
+          raise "Error creating Subscription: (#{response.status}) #{response.body}"
+        end
+        data = response.data
+        subscription = API::Subscription.new(@spire, data) 
+        if subscription_name
+          subscriptions[data["name"]] = subscription
+        end
+        subscription
+      end
+      
+      def channels!
+        response = request(:channels)
+        unless response.status == 200
+          raise "Error retrieving Channels: (#{response.status}) #{response.body}"
+        end
+        channels_data = response.data
+        @channels = {}
+        channels_data.each do |name, properties|
+          @channels[name] = API::Channel.new(@spire, properties)
+        end
+        @channels
+      end
+
+      def channels
+        @channels ||= channels!
+      end
+
+      def subscriptions
+        @subscriptions ||= subscriptions!
+      end
+
+      def subscriptions!
+        response = request(:subscriptions)
+        unless response.status == 200
+          raise "Error retrieving Subscriptions: (#{response.status}) #{response.body}"
+        end
+        @subscriptions = {}
+        response.data.each do |name, properties|
+          @subscriptions[name] = API::Subscription.new(@spire, properties)
+        end
+        @subscriptions
+      end
+      
+      def get_channel(name)
+        response = request(:channel_by_name, name)
+        unless response.status == 200
+          raise "Error finding channel with name #{name}: (#{response.status}) #{response.body}"
+        end
+        properties = response.data[name]
+        channel = API::Channel.new(@spire, properties)
+        @channels[name] = channel if @channels.is_a?(Hash)
+        channel
+      end
+      
+      def get_subscription(name)
+        response = request(:subscription_by_name, name)
+        unless response.status == 200
+          raise "Error finding subscription with name #{name}: (#{response.status}) #{response.body}"
+        end
+        properties = response.data[name]
+        sub = API::Subscription.new(@spire, properties)
+        @subscriptions[name] = sub if @subscriptions.is_a?(Hash)
+        sub
+      end
+    end
+  end
+end

data/lib/spire/api/channel.rb

@@ -2,10 +2,32 @@ class Spire
   class API
 
     class Channel < Resource
+
+      attr_reader :resources
+
+      def initialize(spire, data)
+        super
+        @resources = data["resources"]
+      end
+
       def resource_name
         "channel"
       end
 
+      define_request(:subscriptions) do
+        collection = @resources["subscriptions"]
+        capability = collection["capabilities"]["get_subscriptions"]
+        url = collection["url"]
+        {
+          :method => :get,
+          :url => url,
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("subscriptions"),
+          }
+        }
+      end
+
       define_request(:publish) do |string|
         {
           :method => :post,
@@ -19,15 +41,54 @@ class Spire
         }
       end
 
+      define_request(:subscribe) do |name|
+        collection = @resources["subscriptions"]
+        capability = collection["capabilities"]["create"]
+        url = collection["url"]
+        {
+          :method => :post,
+          :url => url,
+          :body => {:name => name}.to_json,
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("subscription"),
+            "Content-Type" => @spire.mediaType("subscription")
+          }
+        }
+      end
+
+      def subscriptions
+        @subscriptions ||= subscriptions!
+      end
+
+      def subscriptions!
+        response = request(:subscriptions)
+        unless response.status == 200
+          raise "Error getting subscriptions to #{self.class.name}: (#{response.status}) #{response.body}"
+        end
+        @subscriptions = {}
+        response.data.each do |name, properties|
+          @subscriptions[name] = API::Subscription.new(@spire, properties)
+        end
+        @subscriptions
+      end
+
       def publish(content)
         body = {:content => content}.to_json
         response = request(:publish, body)
         unless response.status == 201
           raise "Error publishing to #{self.class.name}: (#{response.status}) #{response.body}"
         end
-        message = response.data
+        API::Message.new(@spire, response.data)
       end
 
+      def subscribe(name = nil)
+        response = request(:subscribe, name)
+        unless response.status == 201
+          raise "Error creating subscription for #{self.name}: (#{response.status}) #{response.body}"
+        end
+        API::Subscription.new(@spire, response.data)
+      end
     end
 
   end

data/lib/spire/api/event.rb

@@ -0,0 +1,27 @@
+class Spire
+  class API
+    class Event < Resource
+      def resource_name
+        "event"
+      end
+    end
+
+    class Message < Event
+      def resource_name
+        "message"
+      end
+    end
+
+    class Join < Event
+      def resource_name
+        "join"
+      end
+    end
+
+    class Part < Event
+      def resource_name
+        "part"
+      end
+    end
+  end
+end

data/lib/spire/api/{message.rb → member.rb}

@@ -1,9 +1,13 @@
 class Spire
   class API
-    class Message < Resource
+
+    class Member < Resource
       def resource_name
-        "message"
+        "member"
       end
+
+
     end
+
   end
 end

data/lib/spire/api/notification.rb

@@ -0,0 +1,100 @@
+class Spire
+  class API
+
+    class Notification < Resource
+      def resource_name
+        "notification"
+      end
+      
+      define_request(:push) do |options|
+        {
+          :method => :post,
+          :url => @url,
+          :body => {
+            :device_tokens => options[:device_tokens],
+            :message => options[:message]
+          }.to_json,
+          :headers => {
+            "Authorization" => "Capability #{@capabilities["push"]}",
+            "Accept" => @spire.mediaType("notification"),
+            "Content-Type" => @spire.mediaType("notification")
+          }
+        }
+      end
+      
+      define_request(:devices) do
+        devices = properties["resources"]["devices"]
+        capability = devices["capabilities"]["devices"]
+        {
+          :method => :get,
+          :url => devices["url"],
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => "application/json"
+          }
+        }
+      end
+      
+      define_request(:register_device) do |data|
+        devices = properties["resources"]["devices"]
+        capability = devices["capabilities"]["register_device"]
+        {
+          :method => :put,
+          :url => devices["url"],
+          :body => data.to_json,
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => "application/json",
+            "Content-Type" => "application/json"
+          }
+        }
+      end
+      
+      define_request(:remove_device) do |data|
+        devices = properties["resources"]["devices"]
+        capability = devices["capabilities"]["remove_device"]
+        {
+          :method => :delete,
+          :url => devices["url"],
+          :body => data.to_json,
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => "application/json",
+            "Content-Type" => "application/json"
+          }
+        }
+      end
+      
+      def send_notification(options={})
+        response = request(:push, options)
+        unless response.status == 200
+          raise "Error sending push notification #{self.class.name}: (#{response.status}) #{response.body}"
+        end
+        response.data
+      end
+      
+      def devices!
+        response = request(:devices)
+        unless response.status == 200
+          raise "Error getting device list #{self.class.name}: (#{response.status}) #{response.body}"
+        end
+        response.data["devices"]
+      end
+      
+      def register_device(device_token)
+        response = request(:register_device, :token => device_token)
+        unless response.status == 200
+          raise "Error adding device #{self.class.name}: (#{response.status}) #{response.body}"
+        end
+        token = response.data["token"]
+        devices[token] = response.data
+      end
+      
+      def devices
+        @devices ||= {}
+      end
+      
+    end
+
+  end
+end

data/lib/spire/api/resource.rb

@@ -65,10 +65,6 @@ class Spire
         properties[name]
       end
 
-      def inspect
-        "#<#{self.class.name}:0x#{object_id.to_s(16)}>"
-      end
-
       def get
         response = request(:get)
         unless response.status == 200

data/lib/spire/api/session.rb

@@ -33,14 +33,20 @@ class Spire
         }
       end
 
-      define_request(:create_channel) do |name|
+      define_request(:create_channel) do |name, limit, ttl|
         collection = @resources["channels"]
         capability = collection["capabilities"]["create"]
         url = collection["url"]
+
+        body = {
+          :name => name,
+          :limit => limit,
+          :ttl => ttl
+        }.to_json
         {
           :method => :post,
           :url => url,
-          :body => { :name => name }.to_json,
+          :body => body,
           :headers => {
             "Authorization" => "Capability #{capability}",
             "Accept" => @spire.mediaType("channel"),
@@ -63,7 +69,13 @@ class Spire
         }
       end
 
-      define_request(:create_subscription) do |subscription_name, channel_urls|
+      define_request(:create_subscription) do |options|
+        name = options[:name]
+        channel_urls = options[:channel_urls]
+        expiration = options[:expiration]
+        device_token = options[:device_token]
+        notification_name = options[:notification_name]
+
         collection = @resources["subscriptions"]
         capability = collection["capabilities"]["create"]
         url = collection["url"]
@@ -72,7 +84,10 @@ class Spire
           :url => url,
           :body => {
             :channels => channel_urls,
-            :name => subscription_name
+            :name => name,
+            :expiration => expiration,
+            :device_token => device_token,
+            :notification_name => notification_name
           }.to_json,
           :headers => {
             "Authorization" => "Capability #{capability}",
@@ -96,6 +111,81 @@ class Spire
           }
         }
       end
+      
+      define_request(:create_notification) do |options|
+        collection = @resources["notifications"]
+        capability = collection["capabilities"]["create"]
+        url = collection["url"]
+        {
+          :method => :post,
+          :url => url,
+          :body => {
+            :name => options[:name],
+            :mode => options[:mode]
+          }.to_json,
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("notification"),
+            "Content-Type" => @spire.mediaType("notification")
+          }
+        }
+      end
+      
+      define_request(:notifications) do
+        collection = @resources["notifications"]
+        capability = collection["capabilities"]["all"]
+        url = collection["url"]
+        {
+          :method => :get,
+          :url => url,
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("notifications"),
+          }
+        }
+      end
+
+      define_request(:applications) do
+        collection = @resources["applications"]
+        capability = collection["capabilities"]["all"]
+        request = {
+          :method => :get,
+          :url => collection["url"],
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("applications"),
+          }
+        }
+      end
+
+      define_request(:application_by_name) do |name|
+        collection = @resources["applications"]
+        capability = collection["capabilities"]["get_by_name"]
+        url = collection["url"]
+        request = {
+          :method => :get,
+          :url => url,
+          :query => {:name => name},
+          :headers => {
+            "Authorization" => "Capability #{capability}",
+            "Accept" => @spire.mediaType("applications"),
+          }
+        }
+      end
+
+      define_request(:create_application) do |data|
+        collection = @resources["applications"]
+        {
+          :method => :post,
+          :url => collection["url"],
+          :body => data.to_json,
+          :headers => {
+            "Authorization" => "Capability #{collection["capabilities"]["create"]}",
+            "Accept" => @spire.mediaType("application"),
+            "Content-Type" => @spire.mediaType("application")
+          }
+        }
+      end
 
       attr_reader :url, :resources, :schema, :capabilities, :capability
 
@@ -116,8 +206,10 @@ class Spire
         @account = API::Account.new(@spire, @resources["account"]).get
       end
 
-      def create_channel(name)
-        response = request(:create_channel, name)
+      def create_channel(name, options={})
+        limit = options[:limit]
+        ttl = options[:ttl]
+        response = request(:create_channel, name, limit, ttl)
         unless response.status == 201
           raise "Error creating Channel: (#{response.status}) #{response.body}"
         end
@@ -125,20 +217,86 @@ class Spire
         channels[name] = API::Channel.new(@spire, properties)
       end
 
-      def create_subscription(subscription_name, channel_names)
-        channel_urls = channel_names.flatten.map { |name| self.channels[name].url rescue nil }.compact
-        response = request(:create_subscription, subscription_name, channel_urls)
+      def create_subscription(subscription_name, channel_names, expiration=nil, device_token=nil, notification_name=nil, second_try=false)
+        channel_urls = channel_names.flatten.map { |name| self.channels[name].url rescue nil }
+        if channel_urls.size != channel_urls.compact.size
+          if !second_try
+            self.channels!
+            return create_subscription(subscription_name, channel_names, expiration, device_token, notification_name, true)
+          else
+            channel_urls = channel_urls.compact
+          end
+        end
+        response = request(:create_subscription, {
+          :name => subscription_name,
+          :channel_urls => channel_urls,
+          :expiration => expiration,
+          :device_token => device_token,
+          :notification_name => notification_name
+        })
+
         unless response.status == 201
           raise "Error creating Subscription: (#{response.status}) #{response.body}"
         end
         data = response.data
-        subscription = API::Subscription.new(@spire, data) 
+        subscription = API::Subscription.new(@spire, data)
         if subscription_name
           subscriptions[data["name"]] = subscription
         end
         subscription
       end
 
+      def get_application(name)
+        response = request(:application_by_name, name)
+        unless response.status == 200
+          raise "Error finding application with name #{name}: (#{response.status}) #{response.body}"
+        end
+        properties = response.data[name]
+        app = API::Application.new(@spire, properties)
+        @applications[name] = app if @applications.is_a?(Hash)
+        app
+      end
+
+      def create_application(name, data = {})
+        data[:name] = name
+        response = request(:create_application, data)
+        unless response.status == 201
+          raise "Error creating Application (#{response.status}) #{response.body}"
+        end
+        properties = response.data
+        applications[name] = API::Application.new(@spire, properties)
+      end
+
+      def applications!
+        response = request(:applications)
+        unless response.status == 200
+          raise "Error retrieving Applications (#{response.status}) #{response.body}"
+        end
+        applications_data = response.data
+        @applications = {}
+        applications_data.each do |name, properties|
+          @applications[name] = API::Application.new(@spire, properties)
+        end
+        @applications
+      end
+
+      def applications
+        @applications ||= applications!
+      end
+
+      def create_notification(options={})
+        response = request(:create_notification, options)
+        unless response.status == 201
+          raise "Error creating Notification: (#{response.status}) #{response.body}"
+        end
+        data = response.data
+        notification = API::Notification.new(@spire, data) 
+        if options[:name]
+          notifications[data["name"]] = notification
+        end
+        notification
+      end
+      
       def channels!
         response = request(:channels)
         unless response.status == 200
@@ -171,6 +329,22 @@ class Spire
         end
         @subscriptions
       end
+      
+      def notifications
+        @notifications ||= notifications!
+      end
+      
+      def notifications!
+        response = request(:notifications)
+        unless response.status == 200
+          raise "Error retrieving Notifications: (#{response.status}) #{response.body}"
+        end
+        @notifications = {}
+        response.data.each do |name, properties|
+          @notifications[name] = API::Notification.new(@spire, properties)
+        end
+        @notifications
+      end
 
     end
 

data/lib/spire/api/subscription.rb

@@ -8,65 +8,91 @@ class Spire
         "subscription"
       end
 
-      define_request(:messages) do |options|
+      define_request(:events) do |options|
         {
           :method => :get,
           :url => @url,
           :query => {
             "timeout" => options[:timeout],
-            "last-message" => options[:last],
+            "last" => options[:last],
             "order-by" => options[:order_by],
             "delay" => options[:delay]
           },
           :headers => {
-            "Authorization" => "Capability #{@capabilities["messages"]}",
+            "Authorization" => "Capability #{@capabilities["events"]}",
             "Accept" => @spire.mediaType("events")
           }
         }
       end
 
+      EVENT_TYPES = ["message", "join", "part"]
+
       def listeners
-        @listeners ||= []
+        if @listeners
+          @listeners
+        else
+          @listeners = { }
+          EVENT_TYPES.each do |type|
+            @listeners[type] = []
+          end
+          @listeners
+        end
       end
 
-      def add_listener(&block)
-        listeners << block
+      def add_listener(type="message", &block)
+        type.downcase!
+        if !EVENT_TYPES.include?(type)
+          throw "Listener type must be one of #{EVENT_TYPES}"
+        end
+
+        listeners[type] << block
         block
       end
 
-      def retrieve_messages(options={})
+      def retrieve_events(options={})
         options[:last] ||= "0"
         options[:delay] ||= 0
         options[:order_by] ||= "desc"
 
-        response = request(:messages, options)
+        response = request(:events, options)
         unless response.status == 200
           raise "Error retrieving messages from #{self.class.name}: (#{response.status}) #{response.body}"
         end
-        messages = response.data["messages"].map do |message|
-          API::Message.new(@spire, message)
-        end
-        @last = messages.last.timestamp unless messages.empty?
-        messages.each do |message|
-          listeners.each do |listener|
-            listener.call(message)
+        @last = response.data["last"] if response.data and response.data["last"]
+
+        event_hash = {
+          :first => response.data["first"],
+          :last => response.data["last"]
+        }
+
+        EVENT_TYPES.each do |type|
+          type_pl = "#{type}s"
+          event_hash[type_pl.to_sym] = []
+          response.data[type_pl].each do |event|
+            klass_name = type.capitalize
+            klass = API.const_get(klass_name)
+            event_obj = klass.new(@spire, event)
+            event_hash[type_pl.to_sym].push(event_obj)
+
+            listeners[type].each do |listener|
+              listener.call(event_obj)
+            end
           end
         end
-        messages
+        event_hash
       end
 
       def poll(options={})
         # timeout option of 0 means no long poll,
         # so we force it here.
         options[:timeout] = 0
-        options[:last] = @last
-        retrieve_messages(options)
+        long_poll(options)
       end
 
       def long_poll(options={})
         options[:timeout] ||= 30
         options[:last] = @last
-        retrieve_messages(options)
+        retrieve_events(options)
       end
 
       def listen(options={})
@@ -76,6 +102,5 @@ class Spire
       end
 
     end
-
   end
 end

data/lib/spire_io.rb

@@ -14,7 +14,9 @@ class Spire
     @api = Spire::API.new(url)
     @url = url
     @channel_error_counts = {}
+    @application_error_counts = {}
     @subscription_error_counts = {}
+    @notification_error_counts = {}
     discover
   end
 
@@ -143,6 +145,68 @@ class Spire
 	def subscriptions
 		@session.subscriptions.values
 	end
+	
+
+  def notification(name, mode="development")
+    Notification.new(
+      @session.notifications[name] || find_or_create_notification(name, ssl_cert)
+    )
+  end
+  
+  def find_or_create_notification(notification_name, mode)
+  	@notification_error_counts[notification_name] ||= 0
+    begin
+      return @session.create_notification(
+          :name => notification_name,
+          :mode => mode
+        )
+    rescue => error
+      if error.message =~ /409/
+      
+        if notification = @session.notification![notification_name]
+          return notification
+        else
+          @notification_error_counts[notification_name] += 1
+          retry unless @notification_error_counts >= RETRY_CREATION_LIMIT
+        end
+      
+      else
+        raise error
+      end
+    end
+  end
+  
+
+  def applications
+    @session.applications
+  end
+
+  def applications!
+    @session.applications!
+  end
+
+  # Creates an application on spire.  Returns an Application object.  Will retry on a 409.
+  # @param [String] Name of the application to find/create
+  def find_or_create_application(name)
+    @application_error_counts[name] ||= 0
+    begin
+      return @session.create_application(name)
+    # TODO custom error class for Conflict, which we can
+    # then match here, instead of testing for error message
+    rescue => error
+      if error.message =~ /409/
+        # Dear retry, I love you.  Affectionately, Matthew.
+        if application = @session.applications![name]
+          return application
+        else
+          @application_error_counts[name] += 1
+          retry unless @application_error_counts[name] >= RETRY_CREATION_LIMIT
+        end
+      else
+        raise error
+      end
+    end
+  end
 
   # Returns a billing object than contains a list of all the plans available
   # @param [String] info optional object description
@@ -210,7 +274,7 @@ class Spire
     # misnamed method, here for backompat.  Should be something like #get_messages,
     # because it only makes one request.
     def listen(options={})
-      long_poll(options).map {|message| message["content"] }
+      long_poll(options)
     end
 
     # wraps the underlying Subscription#add_listener to
@@ -221,7 +285,7 @@ class Spire
       listener_name ||= generate_listener_name
       listener = wrap_listener(&block)
       listeners[listener_name] = listener
-      __getobj__.add_listener(&listener)
+      __getobj__.add_listener("message", &listener)
     end
 
     def remove_listener(arg)
@@ -233,7 +297,7 @@ class Spire
       end
 
       if listener
-        __getobj__.listeners.delete(listener)
+        __getobj__.listeners["message"].delete(listener)
       end
     end
 
@@ -273,4 +337,16 @@ class Spire
 
   end
 
+  class Notification < SimpleDelegator
+
+    # this is required because Delegator's method_missing relies
+    # on the object having a method defined, but in this case
+    # the API::Subscription is also using method_missing
+    def name
+      __getobj__.name
+    end
+    
+    
+  end
+  
 end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: spire_io
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 11
   prerelease: false
   segments: 
   - 1
-  - 0
-  - 0
-  version: 1.0.0
+  - 2
+  version: "1.2"
 platform: ruby
 authors: 
 - Dan Yoder
@@ -17,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-08 00:00:00 -08:00
+date: 2012-05-07 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -142,8 +141,11 @@ extra_rdoc_files: []
 
 files: 
 - lib/spire/api/account.rb
+- lib/spire/api/application.rb
 - lib/spire/api/channel.rb
-- lib/spire/api/message.rb
+- lib/spire/api/event.rb
+- lib/spire/api/member.rb
+- lib/spire/api/notification.rb
 - lib/spire/api/requestable.rb
 - lib/spire/api/resource.rb
 - lib/spire/api/session.rb