purzelrakete-boomloop 0.0.3 → 0.0.4

data/bin/boomloop

@@ -33,8 +33,8 @@ error(parser) unless options.secret && options.key
 
 # negotiate the tokens
 client =  Boomloop::Authentication::Client.new("api", Boomloop::Authentication::Store::YAMLStore.new)
-request_token = client.consume(options.key, options.secret) rescue error("Invalid. Check your credentials at #{ Boomloop::Resources::Base.api_base }oauth/applications.")
-puts "\nalmost ready! go to #{ request_token.authorize_url }\n\n   press enter when you're done... <waiting>\n"
+request_token = client.consume(options.key, options.secret) rescue error("Invalid. Check your credentials at #{ Boomloop::Resources::Base.api_base }/oauth/applications.")
+puts "\nalmost ready! go to #{ request_token.authorize_url.gsub(/\/\/oauth/, '/oauth') }\n\n   press enter when you're done... <waiting>\n"
 
 while !@access_token && gets        
   @access_token = client.activate rescue nil

data/config/credentials.yml

@@ -0,0 +1,6 @@
+--- 
+api: 
+  :consumer_key: j2Nl3hhU09Eo4tSstzbJQ
+  :access_secret: SweZHltNo4LF4mvG2vqp1nbMRNw7ZZLraP65TvrLic
+  :consumer_secret: Uzwy52l8lSVQYZWMVYNv6nphINN0pGrwKmsXiGSUzg
+  :access_key: m4qOECcRym7aW4mtGOw9Fw

data/lib/authentication/client.rb

@@ -1,17 +1,37 @@
 =begin
-  The Client takes two arguments - a config key, and an authentication name. When you authorize using
-  the boomloop script, a config key 'api' is created in the YAMLStore. This holds your the access
-  tokens so that you don't need to negotiate them every time you want to make a request. 
+  When using the booomloop script, a config key 'api' is created in the YAMLStore. This holds 
+  your the access   tokens so that you don't need to negotiate them every time you want to make 
+  a request. 
+  
+  The Client can be instantiated like this: 
+  
+  require 'boomloop'
+  client = Boomloop::Authentication::Client.new("api", Boomloop::Authentication::Store::YAMLStore.new)
+  
+  If you have already activated the 'api' config, you can now get the connection like this: 
+  
+  connection = client.create_accesstoken
+  connection.get("http://api.boomloop.com/events")
+  
 =end
 module Boomloop
   module Authentication
     class Client
       attr_accessor :store, :user
       attr_accessor :consumer, :request_token, :access_token
+      attr_accessor :connection
+      
+      def connection
+        @connection ||= connect
+      end
+      
+      def connect
+        @connection ||= create_accesstoken
+      end
       
       def initialize(user, store)
         self.user = user
-        self.store = store
+        self.store = store        
       end
       
       def consume(key, secret)
@@ -29,13 +49,26 @@ module Boomloop
       end
       
       def create_consumer(key, secret)
-        self.consumer = OAuth::Consumer.new(key, secret, { :site => "http://boomloop.com" })
+        self.consumer = OAuth::Consumer.new(key, secret, { :site => Boomloop::Resources::Base.api_base })
       end
 
       def create_accesstoken
         credentials = self.store.find(self.user)
-        self.consumer ||= create_consumer(credentials['consumer_key'], credentials['consumer_secret'])
-        self.access_token ||= OAuth::AccessToken.new(self.consumer, credentials['access_key'], credentials['access_secret'])
+        raise_error_if_not_authenticated(credentials)        
+        self.consumer ||= create_consumer(credentials[:consumer_key], credentials[:consumer_secret])
+        self.access_token ||= OAuth::AccessToken.new(self.consumer, credentials[:access_key], credentials[:access_secret])
+      end
+      
+      def get(url, options = {})
+        connection.get(url, options.merge({ "X-Consumer-Key" => self.consumer.key }))
+      end
+      
+      def post(url, params = "")
+        connection.post(url, params, { "X-Consumer-Key" => self.consumer.key })
+      end
+            
+      def raise_error_if_not_authenticated(credentials)
+        raise Boomloop::ApiError.new("You need to authenticate the api before getting an access token. Do this by running the command 'boomloop'") unless credentials[:consumer_secret]
       end
     end
   end

data/lib/boomloop.rb

@@ -7,6 +7,8 @@ require 'activesupport'
 
 module Boomloop
   class ApiError < ::StandardError; end
+  class AuthorizationError < ApiError; end
+  class ValidationError < ApiError; end
 end
 
 Dir.glob(File.dirname(__FILE__) + "/**/*.rb").each do |file|

data/lib/resources/base.rb

@@ -2,21 +2,20 @@ module Boomloop
   module Resources
     class Base < ::OpenStruct
       class << self
-        attr_accessor :connection
+        attr_accessor :client
       end
       
       def self.api_base
-        ENV["BOOMLOOP_API_BASE"] || 'http://api.boomloop.com/'
+        @@api_base ||= (ENV["BOOMLOOP_API_URL"] ? ENV["BOOMLOOP_API_URL"].gsub(/\/$/, "") : 'http://api.boomloop.com' )
       end
       
-      def self.connection
-        @@connection ||= init
+      def self.client
+        @@client ||= init
       end
       
       # get oauth token
       def self.init
-        client =  Boomloop::Authentication::Client.new("api", Boomloop::Authentication::Store::YAMLStore.new)
-        self.connection = client.create_accesstoken
+        self.client =  Boomloop::Authentication::Client.new("api", Boomloop::Authentication::Store::YAMLStore.new)
       end
       
       def save
@@ -47,44 +46,52 @@ module Boomloop
       
       # REST methods
       def self.index(params = {})
-        url = api_base + self.plural
+        url = "#{ api_base }/#{ self.plural }"
         url += "?#{ params.to_query }" unless params.empty?
-        xml = connection.get(url)
-        
-        attrs = from_xml(xml)
+        res = client.get(url)
+        attrs = from_response(res)
         construct_resource_collection(attrs)
       end
       
       def self.show(url)
-        xml = connection.get(url)
-        attrs = from_xml(xml)
+        res = client.get(url)
+        attrs = from_response(res)
         self.new(attrs[self.singular])
       end
       
       def self.create(resource)
-        url = api_base + self.plural
-        xml = connection.post(url, resource.to_hash.to_query)
-        self.new(from_xml(xml)[self.singular])
+        url = "#{ api_base }/#{ self.plural }"
+        res = client.post(url, resource.to_hash.to_query)
+        self.new(from_response(res)[self.singular])
       end
       
-      def self.from_xml(response)
-        xml = nil
-        begin
-          xml = Hash.from_xml(response)
-        rescue Exception => e
-          raise Boomloop::APIError.new("Response from boomloop could not be parsed. Response was: \n\n #{ response }")
-        end
+      def self.from_response(response)        
+        xml = response.body
         
-        raise Boomloop::APIError.new("There was a problem with your request: \n\n #{ response }") if xml["errors"]
+        case response.code.to_i
+        when 401
+          raise Boomloop::AuthorizationError.new
+        when 200...299
+          begin  
+            @result = Hash.from_xml(xml)
+          rescue Exception => e
+            raise Boomloop::ApiError.new("Response from boomloop could not be parsed. Response was: \n\n #{ response }")
+          end
+          
+          raise Boomloop::ValidationError.new("There was a problem with your request: \n\n #{ response }") if @result["errors"]
+        else
+          raise Boomloop::ApiError.new("boomloop responded with #{ response.class } (#{ response.code }): #{ response.body }")
+        end      
 
-        xml
+        @result
       end
       
       def self.construct_resource_collection(attrs)
-        collection = attrs[self.plural][self.singular]
+        collection = attrs[self.plural]
+        
         case collection
         when Array : collection.map { |hash| self.new(hash) }
-        when Hash : self.new(collection)
+        when Hash : self.new(collection[self.singular])
         end
       end
       

data/test/boomloop_resource_test.rb

@@ -1,8 +1,10 @@
 require File.dirname(__FILE__) + '/test_helper.rb'
 
 context "a boomloop resource" do
+  
   setup do
-    @connection = Boomloop::Resources::Base.connection
+    Boomloop::Authentication::Client.class_eval { def raise_error_if_not_authenticated(*args); end }
+    @client = Boomloop::Resources::Base.client
   end
   
   specify "should be creatable by passing in a hash of values" do
@@ -16,90 +18,132 @@ context "a boomloop resource" do
     monster.to_hash.should.equal qualities
   end
   
-  specify "should be showable when calling Boomloop::Resources::Monster.show('#{ Boomloop::Resources::Base.api_base }monsters/fred')" do
-    @connection.expects(:get).with("#{ Boomloop::Resources::Base.api_base }monsters/fred").at_least_once.returns(%Q[
+  specify "should be showable when calling Boomloop::Resources::Monster.show('#{ Boomloop::Resources::Base.api_base }/monsters/fred')" do
+    response = mock()
+    response.expects(:code).returns 200
+    response.expects(:body).returns(<<-XML)
       <monster>
-        <resource_url>#{ Boomloop::Resources::Base.api_base }monsters/fred</resource_url>
+        <resource_url>#{ Boomloop::Resources::Base.api_base }/monsters/fred</resource_url>
         <size>huge</size>
         <affect>sanguine</affect>
         <name>fred</name>
       </monster>
-    ])
+    XML
     
-    monster = Boomloop::Resources::Monster.show("#{ Boomloop::Resources::Base.api_base }monsters/fred")
+    @client.expects(:get).with("#{ Boomloop::Resources::Base.api_base }/monsters/fred").at_least_once.returns(response)
+    monster = Boomloop::Resources::Monster.show("#{ Boomloop::Resources::Base.api_base }/monsters/fred")
     monster.name.should.equal "fred"
   end
   
   specify "should be listable when calling Boomloop::Resources::Monster.index" do
-    @connection.expects(:get).with("#{ Boomloop::Resources::Base.api_base }monsters").at_least_once.returns(%Q[
-      <monsters>
+    response = mock()
+    response.expects(:code).returns 200
+    response.expects(:body).returns(<<-XML)
+      <monsters type="array">
         <monster>
-          <resource_url>#{ Boomloop::Resources::Base.api_base }monsters/fred</resource_url>
+          <resource_url>#{ Boomloop::Resources::Base.api_base }/monsters/fred</resource_url>
           <size>huge</size>
           <affect>sanguine</affect>
           <name>fred</name>
         </monster>
         
         <monster>
-          <resource_url>#{ Boomloop::Resources::Base.api_base }monsters/simon</resource_url>
+          <resource_url>#{ Boomloop::Resources::Base.api_base }/monsters/simon</resource_url>
           <size>middling</size>
           <affect>indifferent</affect>
           <name>simon</name>
         </monster>
       </monsters>
-    ])
+    XML
     
+    @client.expects(:get).with("#{ Boomloop::Resources::Base.api_base }/monsters").at_least_once.returns(response)
     monsters = Boomloop::Resources::Monster.index
     monsters.map { |monster| monster.name }.should.include "fred"
   end
   
   specify "should be listable when calling Boomloop::Resources::Monster.index and there is only one result" do
-    @connection.expects(:get).with("#{ Boomloop::Resources::Base.api_base }monsters").at_least_once.returns(%Q[
+    response = mock()
+    response.expects(:code).returns 200
+    response.expects(:body).returns(<<-XML)
       <monsters>
         <monster>
-          <resource_url>#{ Boomloop::Resources::Base.api_base }monsters/fred</resource_url>
+          <resource_url>#{ Boomloop::Resources::Base.api_base }/monsters/fred</resource_url>
           <size>huge</size>
           <affect>sanguine</affect>
           <name>fred</name>
         </monster>
       </monsters>
-    ])
+    XML
     
+    @client.expects(:get).with("#{ Boomloop::Resources::Base.api_base }/monsters").at_least_once.returns(response)
     monsters = Boomloop::Resources::Monster.index
     monsters.name.should.equal "fred"
   end
 
   specify "should be listable with attributes when calling Boomloop::Resources::Monster.index(:affect => :sanguine)" do
-    @connection.expects(:get).with("#{ Boomloop::Resources::Base.api_base }monsters?affect=sanguine").at_least_once.returns(%Q[
+    response = mock()
+    response.expects(:code).returns 200
+    response.expects(:body).returns(<<-XML)
       <monsters>
         <monster>
-          <resource_url>#{ Boomloop::Resources::Base.api_base }monsters/fred</resource_url>
+          <resource_url>#{ Boomloop::Resources::Base.api_base }/monsters/fred</resource_url>
           <size>huge</size>
           <affect>sanguine</affect>
           <name>fred</name>
         </monster>
       </monsters>
-    ])
+    XML
     
+    @client.expects(:get).with("#{ Boomloop::Resources::Base.api_base }/monsters?affect=sanguine").at_least_once.returns(response)
     monsters = Boomloop::Resources::Monster.index(:affect => :sanguine)
     monsters.name.should.equal "fred"
   end
     
   specify "should be savable when calling .save on a Monster instance" do
-    intended_resource_url = "#{ Boomloop::Resources::Base.api_base }monsters/samuel"
+    intended_resource_url = "#{ Boomloop::Resources::Base.api_base }/monsters/samuel"
     intended_attributes = { :size => :laughable, :affect => :mordant, :name => "samuel" }
-    
-    @connection.expects(:post).with("#{ Boomloop::Resources::Base.api_base }monsters", intended_attributes.to_query).at_least_once.returns(%Q[
+    response = mock()
+    response.expects(:code).returns 201
+    response.expects(:body).returns(<<-XML)
       <monster>
         <resource_url>#{ intended_resource_url }</resource_url>
         <size>laughable</size>
         <affect>mordant</affect>
         <name>samuel</name>
       </monster>
-    ])
+    XML
     
+    @client.expects(:post).with("#{ Boomloop::Resources::Base.api_base }/monsters", intended_attributes.to_query).at_least_once.returns(response)
     monster = Boomloop::Resources::Monster.new(intended_attributes)
     monster.save
     monster.resource_url.should.equal intended_resource_url
   end
+  
+  specify "should raise an Api Error if boomoop returned something other than XML" do
+    response = mock()
+    response.expects(:code).returns 200
+    response.expects(:body).returns(<<-XML)
+    XML
+    
+    @client.expects(:get).with("#{ Boomloop::Resources::Base.api_base }/monsters/fred").at_least_once.returns(response)
+
+    should.raise Boomloop::ApiError do
+      Boomloop::Resources::Monster.show("#{ Boomloop::Resources::Base.api_base }/monsters/fred")
+    end
+  end
+  
+  specify "should raise an error if boomloop returned an Errors XML" do
+    response = mock()
+    response.expects(:code).returns 200
+    response.expects(:body).returns(<<-XML)
+      <errors>
+        <error>you left the iron on!</error>
+      </errors>
+    XML
+    
+    @client.expects(:get).with("#{ Boomloop::Resources::Base.api_base }/monsters/fred").at_least_once.returns(response)
+    should.raise Boomloop::ValidationError do
+      Boomloop::Resources::Monster.show("#{ Boomloop::Resources::Base.api_base }/monsters/fred")
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: purzelrakete-boomloop
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Rany Keddo
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-05-21 00:00:00 -07:00
+date: 2008-05-26 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency