spire_io 1.0.0.alpha.5 → 1.0.0.beta.1

data/lib/spire/api/account.rb

@@ -0,0 +1,60 @@
+class Spire
+  class API
+
+    class Account < Resource
+      def resource_name
+        "account"
+      end
+
+      define_request(:billing_subscription) do |info|
+        billing = properties["billing"]
+        {
+          :method => :put,
+          :url => billing["url"],
+          :body => info.to_json,
+          :headers => {
+            "Accept" => media_type, "Content-Type" => media_type,
+            "Authorization" => "Capability #{billing["capability"]}"
+          }
+        }
+      end
+
+      define_request(:billing_invoices) do
+        invoices = properties["billing"]["invoices"]
+        {
+          :method => :get,
+          :url => invoices["url"],
+          :headers => {
+            "Accept" => "application/json",
+            "Authorization" => "Capability #{invoices["capability"]}"
+          }
+        }
+      end
+
+      define_request(:billing_invoices_upcoming) do
+        upcoming = properties["billing"]["invoices"]["upcoming"]
+        {
+          :method => :get,
+          :url => upcoming["url"],
+          :headers => {
+            "Accept" => "application/json",
+            "Authorization" => "Capability #{upcoming["capability"]}"
+          }
+        }
+      end
+
+      # Updates and subscribe the account to a billing plan
+      # @param [Object] info data containing billing description
+      # @return [Account]
+      def billing_subscription(info)
+        response = request(:billing_subscription)
+        raise "Error attempting to update account billing: (#{response.status}) #{response.body}" if response.status != 200
+        properties = response.data
+        #@resources["account"] = JSON.parse(response.body)
+        self
+      end
+
+    end
+
+  end
+end

data/lib/spire/api/channel.rb

@@ -0,0 +1,34 @@
+class Spire
+  class API
+
+    class Channel < Resource
+      def resource_name
+        "channel"
+      end
+
+      define_request(:publish) do |string|
+        {
+          :method => :post,
+          :url => @url,
+          :body => string,
+          :headers => {
+            "Authorization" => "Capability #{@capability}",
+            "Accept" => @spire.mediaType("message"),
+            "Content-Type" => @spire.mediaType("message")
+          }
+        }
+      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
+      end
+
+    end
+
+  end
+end

data/lib/spire/api/requestable.rb

@@ -0,0 +1,103 @@
+require "delegate"
+
+class Spire
+  class API
+
+    module Requestable
+
+      def self.included(mod)
+        mod.module_eval do
+          extend(ClassMethods)
+          include(InstanceMethods)
+        end
+      end
+
+      module ClassMethods
+        def requests
+          @requests ||= {}
+        end
+
+        def get_request(name)
+          if req = requests[name]
+            req
+          elsif superclass.respond_to?(:get_request)
+            superclass.get_request(name)
+          else
+            nil
+          end
+        end
+
+        def define_request(name, &block)
+          requests[name] = block
+        end
+      end
+
+      module InstanceMethods
+        def prepare_request(name, *args)
+          if block = self.class.get_request(name)
+            options = self.instance_exec(*args, &block)
+            Request.new(@client, options)
+          else
+            raise ArgumentError, "No request has been defined for #{name.inspect}"
+          end
+        end
+
+        def request(name, *args)
+          prepare_request(name, *args).exec
+        end
+      end
+
+      class Request
+        attr_accessor :url
+        def initialize(client, options)
+          @client = client
+          @method = options.delete(:method) 
+          @url = options.delete(:url) 
+          @options = options
+          @options[:headers] = {
+            "User-Agent" => "Ruby spire.io client"
+          }.merge(@options[:headers] || {})
+        end
+
+        def headers
+          @options[:headers]
+        end
+
+        def body
+          @options[:body]
+        end
+
+        def body=(val)
+          @options[:body] = val
+        end
+
+        def query
+          @options[:query]
+        end
+
+        def exec
+          response = Response.new(@client.send(@method, @url, @options))
+          headers = response.headers
+          content_type = headers.values_at("Content-Type", "content-type").compact.first
+          if content_type =~ /json/ && [200, 201].include?(response.status)
+            # FIXME: detect appropriate response headers, rather than rescuing
+            begin
+              response.data = API.deserialize(response.body)
+            rescue
+            end
+          end
+          response
+        end
+
+        class Response < SimpleDelegator
+          attr_accessor :data
+        end
+      end
+
+    end
+
+
+
+    
+  end
+end

data/lib/spire/api/resource.rb

@@ -0,0 +1,109 @@
+class Spire
+  class API
+    class Resource
+      include Requestable
+
+      define_request(:get) do
+        {
+          :method => :get,
+          :url => @url,
+          :headers => {
+            "Authorization" => "Capability #{@capability}",
+            "Accept" => media_type
+          }
+        }
+      end
+
+      define_request(:update) do |properties|
+        {
+          :method => :put,
+          :url => @url,
+          :body => properties.to_json,
+          :headers => {
+            "Authorization" => "Capability #{@capability}",
+            "Accept" => media_type,
+            "Content-Type" => media_type
+          }
+        }
+      end
+
+      define_request(:delete) do
+        {
+          :method => :delete,
+          :url => @url,
+          :headers => { 
+            "Authorization" => "Capability #{@capability}",
+            "Accept" => media_type,
+            "Content-Type" => media_type,
+          }
+        }
+      end
+  
+      attr_reader :url, :capability, :properties
+
+      def initialize(spire, data)
+        @spire = spire
+        @client = spire.client
+        @url = data["url"]
+        @capability = data["capability"]
+        @properties = data
+      end
+
+      def key
+        properties["key"]
+      end
+
+      def method_missing(name, *args)
+        if description = schema["properties"][name.to_s]
+          properties[name.to_s]
+        else
+          super
+        end
+      end
+
+      def [](name)
+        properties[name]
+      end
+
+      def inspect
+        "#<#{self.class.name}:0x#{object_id.to_s(16)}>"
+      end
+
+      def get
+        response = request(:get)
+        unless response.status == 200
+          raise "Error retrieving #{self.class.name}: (#{response.status}) #{response.body}"
+        end
+        @properties = response.data
+        self
+      end
+
+      def update(properties)
+        response = request(:update, properties)
+        unless response.status == 200
+          raise "Error updating #{self.class.name}: (#{response.status}) #{response.body}"
+        end
+        @properties = response.data
+        self
+      end
+
+      def delete
+        response = request(:delete)
+        unless response.status == 204
+          raise "Error deleting #{self.class.name}: (#{response.status}) #{response.body}"
+        end
+        true
+      end
+
+      def schema
+        @spire.schema[resource_name]
+      end
+
+      def media_type
+        schema["mediaType"]
+      end
+    end
+
+  end
+end
+

data/lib/spire/api/session.rb

@@ -0,0 +1,166 @@
+class Spire
+  class API
+
+    class Session
+      include Requestable
+
+      define_request(:account) do
+        resource = @resources["account"]
+        {
+          :method => :get,
+          :url => resource["url"],
+          :headers => {
+            "Authorization" => "Capability #{resource["capability"]}",
+            "Accept" => @spire.mediaType("account")
+          }
+        }
+      end
+
+      define_request(:channels) do
+        collection = @resources["channels"]
+        request = {
+          :method => :get,
+          :url => collection["url"],
+          :headers => {
+            "Authorization" => "Capability #{collection["capability"]}",
+            "Accept" => @spire.mediaType("channels"),
+          }
+        }
+      end
+
+      define_request(:channel_by_name) do |name|
+        collection = @resources["channels"]
+        request = {
+          :method => :get,
+          :url => collection["url"],
+          :query => {:name => name},
+          :headers => {
+            "Authorization" => "Capability #{collection["capability"]}",
+            "Accept" => @spire.mediaType("channels"),
+          }
+        }
+      end
+
+      define_request(:create_channel) do |name|
+        collection = @resources["channels"]
+        {
+          :method => :post,
+          :url => collection["url"],
+          :body => { :name => name }.to_json,
+          :headers => {
+            "Authorization" => "Capability #{collection["capability"]}",
+            "Accept" => @spire.mediaType("channel"),
+            "Content-Type" => @spire.mediaType("channel")
+          }
+        }
+      end
+
+      define_request(:create_subscription) do |subscription_name, channel_urls|
+        collection = @resources["subscriptions"]
+        {
+          :method => :post,
+          :url => collection["url"],
+          :body => {
+            :channels => channel_urls,
+            :name => subscription_name
+          }.to_json,
+          :headers => {
+            "Authorization" => "Capability #{collection["capability"]}",
+            "Accept" => @spire.mediaType("subscription"),
+            "Content-Type" => @spire.mediaType("subscription")
+          }
+        }
+      end
+
+      attr_reader :url, :resources, :schema, :capability
+
+      def initialize(spire, data)
+        @spire = spire
+        @client = spire.client
+        @schema = spire.schema["session"]
+        @url = data["url"]
+        @capability = data["capability"]
+        @resources = data["resources"]
+      end
+
+      def account
+        @account ||= account!
+      end
+
+      def account!
+        @account = API::Account.new(@spire, @resources["account"]).get
+      end
+
+      def create_channel(name)
+        response = request(:create_channel, name)
+        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
+        subscriptions[data["name"]] = API::Subscription.new(@spire, data)
+      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
+
+       # Not yet in Spire API
+      #define_request(:subscriptions) do
+        #{
+          #:method => :get,
+          #:url => @resources["subscriptions"]["url"],
+          #:headers => {
+            #"Authorization" => "Capability #{@resources["subscriptions"]["capability"]}",
+            #"Accept" => @spire.mediaType("subscription"),
+          #}
+        #}
+      #end
+
+     def subscriptions
+        if @subscriptions
+          @subscriptions
+        else
+          # TODO Fix this to use an API call once Spire supports it
+          @subscriptions = {}
+          channels.each do |name, channel|
+            if subs = channel.properties["subscriptions"]
+              subs.each do |key, sub|
+                @subscriptions[key] = API::Subscription.new(@spire, sub)
+              end
+            end
+          end
+          @subscriptions
+        end
+      end
+
+     def subscriptions!
+       raise "unimplemented"
+     end
+
+    end
+
+  end
+end

data/lib/spire/api/subscription.rb

@@ -0,0 +1,79 @@
+class Spire
+  class API
+
+    class Subscription < Resource
+
+      attr_reader :last
+      def resource_name
+        "subscription"
+      end
+
+      define_request(:messages) do |options|
+        {
+          :method => :get,
+          :url => @url,
+          :query => {
+            "timeout" => options[:timeout],
+            "last-message" => options[:last],
+            "order-by" => options[:order_by],
+            "delay" => options[:delay]
+          },
+          :headers => {
+            "Authorization" => "Capability #{@capability}",
+            "Accept" => @spire.mediaType("events")
+          }
+        }
+      end
+
+      def listeners
+        @listeners ||= []
+      end
+
+      def add_listener(&block)
+        listeners << block
+        block
+      end
+
+      def retrieve_messages(options={})
+        options[:last] ||= "0"
+        options[:delay] ||= 0
+        options[:order_by] ||= "desc"
+
+        response = request(:messages, options)
+        unless response.status == 200
+          raise "Error retrieving messages from #{self.class.name}: (#{response.status}) #{response.body}"
+        end
+        messages = response.data["messages"]
+        @last = messages.last["timestamp"] unless messages.empty?
+        messages.each do |message|
+          listeners.each do |listener|
+            listener.call(message)
+          end
+        end
+        messages
+      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)
+      end
+
+      def long_poll(options={})
+        options[:timeout] ||= 30
+        options[:last] = @last
+        retrieve_messages(options)
+      end
+
+      def listen(options={})
+        loop do
+          break unless yield(long_poll(options))
+        end
+      end
+
+    end
+
+  end
+end

data/lib/spire/api.rb

@@ -0,0 +1,165 @@
+require "rubygems"
+gem "excon"
+require "excon"
+gem "json"
+require "json"
+
+require "spire/api/requestable"
+require "spire/api/resource"
+require "spire/api/session"
+require "spire/api/account"
+require "spire/api/channel"
+require "spire/api/subscription"
+
+class Spire
+
+  class API
+    include Requestable
+
+    def self.deserialize(string)
+      JSON.parse(string, :symbolize_names => false)
+    end
+
+    attr_reader :client, :description, :schema
+    def initialize(url="https://api.spire.io", options={})
+      @version = options[:version] || "1.0"
+      @client = Excon
+      @url = url
+    end
+
+    def inspect
+      "#<Spire::API:0x#{object_id.to_s(16)} @url=#{@url.dump}>"
+    end
+
+    define_request(:discover) do
+      {
+        :method => :get,
+        :url => @url,
+        :headers => {"Accept" => "application/json"}
+      }
+    end
+
+    define_request(:create_session) do |key|
+      {
+        :method => :post,
+        :url => @description["resources"]["sessions"]["url"],
+        :body => {:key => key}.to_json,
+        :headers => {
+          "Accept" => mediaType("session"),
+          "Content-Type" => mediaType("account")
+        }
+      }
+    end
+
+    define_request(:login) do |email, password|
+      {
+        :method => :post,
+        :url => @description["resources"]["sessions"]["url"],
+        :body => { :email => email, :password => password }.to_json,
+        :headers => {
+          "Accept" => mediaType("session"),
+          "Content-Type" => mediaType("account")
+        }
+      }
+    end
+
+    define_request(:create_account) do |info|
+      {
+        :method => :post,
+        :url => @description["resources"]["accounts"]["url"],
+        :body => {
+          :email => info[:email],
+          :password => info[:password],
+          :password_confirmation => info[:password_confirmation]
+        }.to_json,
+        :headers => { 
+          "Accept" => mediaType("session"),
+          "Content-Type" => mediaType("account")
+        }
+      }
+    end
+
+    define_request(:password_reset) do |email|
+      {
+        :method => :post,
+        :url => @description["resources"]["accounts"]["url"],
+        :query => { :email => email },
+        :body => ""
+      }
+    end
+
+    define_request(:billing) do
+      {
+        :method => :get,
+        :url => @description["resources"]["billing"]["url"],
+        :headers => {
+          "Accept" => "application/json"
+        }
+      }
+    end
+
+
+    def discover
+      response = request(:discover)
+      raise "Error during discovery: #{response.status}" if response.status != 200
+      @description = response.data
+      @schema = @description["schema"][@version]
+    end
+
+    def mediaType(name)
+      schema[name]["mediaType"]
+    end
+   
+    def create_session(key)
+      response = request(:create_session, key)
+      raise "Error starting a key-based session" if response.status != 201
+      session_data = response.data
+      API::Session.new(self, session_data)
+    end
+
+    # Authenticates a session using a login and password
+    def login(login, password)
+      response = request(:login, login, password)
+      raise "Error attemping to login:  (#{response.status}) #{response.body}" if response.status != 201
+      session_data = response.data
+      API::Session.new(self, session_data)
+    end
+
+    # Register for a new spire account, and authenticates as the newly created account
+    # @param [String] :email Email address of new account
+    # @param [String] :password Password of new account
+    def create_account(info)
+      response = request(:create_account, info)
+      if response.status != 201
+        raise "Error attempting to register: (#{response.status}) #{response.body}"
+      end
+      session_data = response.data
+      API::Session.new(self, session_data)
+    end
+
+    def password_reset_request(email)
+      response = request(:password_reset)
+      unless response.status == 202
+        raise "Error requesting password reset: (#{response.status}) #{response.body}"
+      end
+      response
+    end
+
+    # Returns a billing object than contains a list of all the plans available
+    # @param [String] info optional object description
+    # @return [Billing]
+    def billing(info=nil)
+      response = request(:billing)
+      raise "Error getting billing plans: #{response.status}" if response.status != 200
+      API::Billing.new(self, response.data)
+    end
+    
+    class Billing < Resource
+      def resource_name
+        "billing"
+      end
+    end
+
+  end
+
+end

data/lib/spire_io.rb

@@ -1,14 +1,11 @@
 require "delegate"
-gem "excon"
-require "excon"
-gem "json"
-require "json"
 
 require "spire/api"
 
 class Spire
 
-	#How many times we will try to create a channel or subscription after getting a 409
+  # How many times we will try to fetch a channel or subscription after
+  # getting a 409 Conflict.
   RETRY_CREATION_LIMIT = 3
 
   attr_accessor :api, :session, :resources
@@ -16,19 +13,13 @@ class Spire
   def initialize(url="https://api.spire.io")
     @api = Spire::API.new(url)
     @url = url
-    @channels = {}
-    @subscriptions = {}
     @channel_error_counts = {}
     @subscription_error_counts = {}
     discover
   end
 
   def key
-    @resources["account"]["key"]
-  end
-  
-  def mediaType(name)
-    @description["schema"]["1.0"][name]["mediaType"]
+    @session.resources["account"]["key"]
   end
   
   def discover
@@ -56,16 +47,8 @@ class Spire
     self
   end
 
-  def key
-    @session.resources["account"]["key"]
-  end
-
   def password_reset_request(email)
-    response = request(:password_reset)
-    unless response.status == 202
-      raise "Error requesting password reset: (#{response.status}) #{response.body}"
-    end
-    response
+    @api.password_reset_request(email)
   end
 
 
@@ -78,47 +61,8 @@ class Spire
   # See Spire docs for available settings
   def update(info)
     @session.account.update(info)
-    #response = request(:update_account, info)
-    #raise "Error attempting to update account: (#{response.status}) #{response.body}" if response.status != 200
-    #@resources["account"] = JSON.parse(response.body)
-    self
-  end
-
-	def retrieve_session
-    response = request(:session)
-    cache_session(JSON.parse(response.body))
-    raise "Error reloading session: #{response.status}" if response.status != 200
     self
-	end
-
-  def cache_session(data)
-    @session = data
-    @resources = @session["resources"]
-    retrieve_channels
-  end
-
-  def retrieve_channels
-    response = request(:channels)
-    unless response.status == 200
-      raise "Error retrieving channels: (#{response.status}) #{response.body}"
-    end
-    cache_channels(JSON.parse(response.body))
   end
- 
-  def cache_channels(data)
-    @channels = {}
-    data.each do |name, properties|
-      @channels[name] = Channel.new(self, properties)
-      cache_channel_subscriptions(properties["subscriptions"])
-    end
-    @channels
-  end
-
-	def cache_channel_subscriptions(data)
-		data.each do |name, properties|
-			@subscriptions[name] = Subscription.new(self, properties)
-		end
-	end
 
   # Returns a channel object for the named channel
   # @param [String] name Name of channel returned
@@ -131,6 +75,10 @@ class Spire
     @session.channels
   end
 
+  def channels!
+    @session.channels!
+  end
+
   # Creates a channel on spire.  Returns a Channel object.  Note that this will
   # fail with a 409 if a channel with the same name exists.
   def find_or_create_channel(name)
@@ -207,10 +155,7 @@ class Spire
   # @return [Account]
   def billing_subscription(info)
     @session.account.billing_subscription(info)
-    #response = request(:billing_subscription)
-    #raise "Error attempting to update account billing: (#{response.status}) #{response.body}" if response.status != 200
-    #@resources["account"] = JSON.parse(response.body)
-    #self
+    self
   end
 
 
@@ -278,11 +223,17 @@ class Spire
       __getobj__.add_listener(&listener)
     end
 
-    def remove_listener(listener)
-      if listener.is_a? String
-        listener = listeners[listener]
+    def remove_listener(arg)
+      if arg.is_a? String
+        listener = listeners.delete(arg)
+      else
+        name, _listener = listeners.detect {|k,v| v == arg }
+        listener = listeners.delete(name)
+      end
+
+      if listener
+        __getobj__.listeners.delete(listener)
       end
-      __getobj__.listeners.delete(listener)
     end
 
     def wrap_listener(&block)
@@ -321,25 +272,4 @@ class Spire
 
   end
 
-
-  ## Object representing a Spire billing
-  ##
-  ## You can get all the billing plans by calling the method billing in Spire object
-  ## * spire = Spire.new
-  ## * billing = spire.billing()
-  ## * plans = billing.plans
-  #class Billing
-    #def initialize(spire,properties)
-      #@spire = spire
-      #@properties = properties
-    #end
-    
-    #def url
-      #@properties["url"]
-    #end
-    
-    #def plans
-      #@properties["plans"]
-    #end
-  #end
 end

metadata

@@ -1,24 +1,25 @@
 --- !ruby/object:Gem::Specification 
 name: spire_io
 version: !ruby/object:Gem::Version 
-  hash: -3702664330
+  hash: 62196353
   prerelease: true
   segments: 
   - 1
   - 0
   - 0
-  - alpha
-  - 5
-  version: 1.0.0.alpha.5
+  - beta
+  - 1
+  version: 1.0.0.beta.1
 platform: ruby
 authors: 
 - Dan Yoder
 - Daniel Lockhart dlockhart@spire.io
+- Matthew King mking@spire.io
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2012-01-27 00:00:00 -08:00
+date: 2012-02-01 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -81,11 +82,28 @@ dependencies:
         version: "0.7"
   type: :development
   version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: redcarpet
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :development
+  version_requirements: *id005
 description: "\t\tThe spire_io gem allows you to quickly and easily use the spire.io service\n\
   \t\tusing Ruby. See http://www.spire.io/ for more.\n"
 email: 
 - dan@spire.io
 - 
+- 
 executables: []
 
 extensions: []
@@ -93,6 +111,13 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/spire/api/account.rb
+- lib/spire/api/channel.rb
+- lib/spire/api/requestable.rb
+- lib/spire/api/resource.rb
+- lib/spire/api/session.rb
+- lib/spire/api/subscription.rb
+- lib/spire/api.rb
 - lib/spire_io.rb
 has_rdoc: true
 homepage: https://github.com/spire-io/spire.io.rb