panda 1.3.0 → 1.4.0

data/lib/panda/config.rb

@@ -0,0 +1,58 @@
+require 'uri'
+
+module Panda
+  class Config
+    
+    def config
+      @config ||= {}
+    end
+    
+    [:api_host, :api_port, 
+     :access_key, :secret_key, 
+     :api_version, :cloud_id].each do |attr|
+      define_method "#{attr}" do |value|
+        config["#{attr.to_s}"] = value
+      end
+
+      define_method "#{attr}=" do |value|
+        config["#{attr.to_s}"] = value
+      end
+    end
+    
+    def to_hash
+      config
+    end
+    
+    def adapter(adapter_name)
+      Panda.adapter = adapter_name
+    end
+    
+    def adapter=(adapter_name)
+      Panda.adapter = adapter_name
+    end
+        
+    # Setup connection for Heroku
+    def parse_panda_url(panda_url)
+      panda_uri = URI.parse(panda_url)
+
+      config['access_key'] = panda_uri.user
+      config['secret_key'] = panda_uri.password
+      config['cloud_id']   = panda_uri.path[1..-1]
+      config['api_host']   = panda_uri.host
+      config['api_port']   = API_PORT
+      config
+    end
+    
+    # Set the correct api_host for US/EU
+    def region(region)
+      if(region.to_s == 'us')
+        config['api_host'] = US_API_HOST
+      elsif(region.to_s == 'eu')
+        config['api_host'] = EU_API_HOST
+      else
+        raise "Region Unknown"
+      end
+    end
+    
+  end
+end

data/lib/panda/connection.rb

@@ -1,84 +1,40 @@
 module Panda
+  
+  API_PORT=443
+  US_API_HOST="api.pandastream.com"
+  EU_API_HOST="api.eu.pandastream.com"
+  
   class Connection
-    attr_accessor :api_host, :api_port, :access_key, :secret_key, :api_version, :cloud_id, :format
+    attr_accessor :api_host, :api_port, :access_key, :secret_key, :api_version, :cloud_id
 
-    API_PORT=443
-    US_API_HOST="api.pandastream.com"
-    EU_API_HOST="api.eu.pandastream.com"
-
-    def initialize(auth_params={}, options={})
-      @raise_error = false
+    def initialize(auth_params={})
       @api_version = 2
-      @format = "hash"
-
-      if auth_params.class == String
-        self.format = options[:format] || options["format"]
-        init_from_uri(auth_params)
-      else
-        self.format = auth_params[:format] || auth_params["format"]
-        init_from_hash(auth_params)
-      end
-    end
-
-    # Set the correct api_host for US/EU
-    def region=(region)
-      if(region.to_s == "us")
-        self.api_host = US_API_HOST
-      elsif(region.to_s == "eu")
-        self.api_host = EU_API_HOST
-      else
-        raise "Region Unknown"
-      end
-    end
-
-    # Setup connection for Heroku
-    def heroku=(url)
-      init_from_uri(url)
+      init_from_hash(auth_params)
     end
 
-    # Raise exception on non JSON parsable response if set
-    def raise_error=(bool)
-      @raise_error = bool
+    def adapter
+      @adapter ||= Panda.adapter.new(api_url)
     end
-
-    # Setup respond type JSON / Hash
-    def format=(ret_format)
-      if ret_format
-        raise "Format unknown" if !["json", "hash"].include?(ret_format.to_s)
-        @format = ret_format.to_s
-      end
-    end
-
+    
     # Authenticated requests
-
     def get(request_uri, params={})
-      @connection = RestClient::Resource.new(api_url)
-      rescue_restclient_exception do
-        query = signed_query("GET", request_uri, params)
-        body_of @connection[request_uri + '?' + query].get
-      end
+      sp = signed_params("GET", request_uri, params)
+      adapter.get(request_uri, sp)
     end
 
     def post(request_uri, params={})
-      @connection = RestClient::Resource.new(api_url)
-      rescue_restclient_exception do
-        body_of @connection[request_uri].post(signed_params("POST", request_uri, params))
-      end
+      sp = signed_params("POST", request_uri, params)
+      adapter.post(request_uri, sp)
     end
 
     def put(request_uri, params={})
-      @connection = RestClient::Resource.new(api_url)
-      rescue_restclient_exception do
-        body_of @connection[request_uri].put(signed_params("PUT", request_uri, params))
-      end
+      sp = signed_params("PUT", request_uri, params)
+      adapter.put(request_uri, sp)
     end
 
     def delete(request_uri, params={})
-      @connection = RestClient::Resource.new(api_url)
-      rescue_restclient_exception do
-        query = signed_query("DELETE", request_uri, params)
-        body_of @connection[request_uri + '?' + query].delete
-      end
+      sp = signed_params("DELETE", request_uri, params)
+      adapter.delete(request_uri, sp)
     end
 
     # Signing methods
@@ -88,9 +44,9 @@ module Panda
 
     def signed_params(verb, request_uri, params = {}, timestamp_str = nil)
       auth_params = stringify_keys(params)
-      auth_params['cloud_id']   = cloud_id
+      auth_params['cloud_id']   = cloud_id unless request_uri =~ /^\/clouds/
       auth_params['access_key'] = access_key
-      auth_params['timestamp']  = timestamp_str || Time.now.iso8601(6)
+      auth_params['timestamp']  = timestamp_str || Time.now.utc.iso8601(6)
 
       params_to_sign = auth_params.reject{|k,v| ['file'].include?(k.to_s)}
       auth_params['signature']  = ApiAuthentication.generate_signature(verb, request_uri, api_host, secret_key, params_to_sign)
@@ -98,10 +54,10 @@ module Panda
     end
 
     def api_url
-      "#{api_protocol}://#{api_host}:#{api_port}/#{@prefix}"
+      "#{api_scheme}://#{api_host}:#{api_port}/#{@prefix}"
     end
 
-    def api_protocol
+    def api_scheme
       api_port == 443 ? 'https' : 'http'
     end
     
@@ -109,8 +65,8 @@ module Panda
     def setup_bucket(params={})
       granting_params = { 
         :s3_videos_bucket => params[:bucket],
-        :user_aws_key => params[:access_key],
-        :user_aws_secret => params[:secret_key]
+        :aws_access_key => params[:access_key],
+        :aws_secret_key => params[:secret_key]
       }
 
       put("/clouds/#{@cloud_id}.json", granting_params)
@@ -125,61 +81,16 @@ module Panda
     end
 
     private
-      def stringify_keys(params)
-        params.inject({}) do |options, (key, value)|
-          options[key.to_s] = value
-          options
-        end
-      end
 
-      def rescue_restclient_exception(&block)
-        begin
-          yield
-        rescue RestClient::Exception => e
-          format_to(e.http_body)
-        end
-      end
-
-      # API change on rest-client 1.4
-      def body_of(response)
-        json_response = response.respond_to?(:body) ? response.body : response
-        format_to(json_response)
-      end
-
-      def format_to(response)
-        begin
-          if self.format == "json"
-            response
-          elsif defined?(ActiveSupport::JSON)
-            ActiveSupport::JSON.decode(response)
-          else
-            JSON.parse(response)
-          end
-        rescue JSON::ParserError => e
-          # if not used with PandaResources
-          # don't raise Service Not Available because
-          # maybe the host, the url, or anything is wrongly setup
-          if @raise_error
-            raise ServiceNotAvailable.new
-          else
-            raise e
-          end
-        end
-      end
-
-      def init_from_uri(uri)
-        heroku_uri = URI.parse(uri)
-        
-        @access_key = heroku_uri.user
-        @secret_key = heroku_uri.password
-        @cloud_id   = heroku_uri.path[1..-1]
-        @api_host   = heroku_uri.host
-        @api_port   = heroku_uri.port
-        @prefix     = "v#{api_version}"
+    def stringify_keys(params)
+      params.inject({}) do |options, (key, value)|
+        options[key.to_s] = value
+        options
       end
+    end
 
-      def init_from_hash(hash_params)
-        params      = { :api_host => US_API_HOST, :api_port => API_PORT }.merge!(hash_params)
+    def init_from_hash(hash_params)
+      params = { :api_host => US_API_HOST, :api_port => API_PORT }.merge!(hash_params)
 
         @cloud_id   = params["cloud_id"]    || params[:cloud_id]
         @access_key = params["access_key"]  || params[:access_key]
@@ -187,7 +98,7 @@ module Panda
         @api_host   = params["api_host"]    || params[:api_host]
         @api_port   = params["api_port"]    || params[:api_port]
         @prefix     = params["prefix_url"]  || "v#{api_version}"
-      end
+    end
   end
 end
 

data/lib/panda/errors.rb

@@ -0,0 +1,17 @@
+module Panda
+  
+  class Error < StandardError; end
+  
+  class APIError < Panda::Error
+    def initialize(options)
+      super("#{options['error']}: #{options['message']}")
+    end
+  end
+
+  class ServiceNotAvailable < Panda::Error
+    def initialize
+      super("ServiceNotAvailable")
+    end
+  end
+
+end

data/lib/panda/modules/builders.rb

@@ -2,35 +2,43 @@ module Panda
   module Builders
 
     def self.included(base)
-      base.extend(CreateBuilder)
-      base.extend(DeleteBuilder)
+      base.extend(ClassMethods)
     end
 
-    module CreateBuilder
+    module ClassMethods
 
-      def create(attributes)       
+      def create(attributes={})
        resource = build_resource(attributes)
+       yield resource if block_given?
+
        resource.create
        resource
       end
 
-      def create!(attributes)
+      def create!(attributes={})
         resource = build_resource(attributes)
+        yield resource if block_given?
+
         resource.create!
         resource
       end
 
       private
+      
       def build_resource(attributes)
         Panda::const_get("#{sti_name}").new(attributes.merge(:cloud_id => cloud.id))
       end
     end
 
-    module DeleteBuilder
-      def delete(id)
-        response = connection.delete(full_object_url(object_url(one_path,{:id =>id})))
-        response['deleted'] == 'ok'
-      end
+    def create
+      raise "Can't create attribute. Already have an id=#{attributes['id']}" if attributes['id']
+      uri = replace_pattern_with_self_variables(self.class.many_path)
+      response = connection.post(uri, attributes)
+      load_and_reset(response)
+    end
+
+    def create!
+      create || raise(errors.last)
     end
 
   end

data/lib/panda/modules/destroyers.rb

@@ -0,0 +1,25 @@
+module Panda
+  module Destroyers
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def delete(id)
+        uri = json_path(create_rest_url(one_path,{:id =>id}))
+        response = connection.delete(uri)
+        response['deleted'] == 'ok'
+      end
+      
+    end
+
+    def delete
+      uri = replace_pattern_with_self_variables(self.class.one_path)
+      response = connection.delete(uri)
+      !!response['deleted']
+    end
+
+  end
+end

data/lib/panda/modules/finders.rb

@@ -1,16 +1,22 @@
 module Panda
   module Finders
 
+    def self.included(base)
+      base.extend(FindOne)
+      base.extend(FindMany)
+    end
+    
     module FindOne
 
       def find(id)
+        raise 'find method requires a correct value' if id.nil? || id == ''
         find_by_path(one_path, {:id => id})
       end
 
       def find_object_by_path(url, map={})
-        full_url = object_url(url, map)
-        params = element_params(url, map)
-        self.connection.get(full_url, params)
+        rest_url = create_rest_url(url, map)
+        params = extract_unmapped_variables(url, map)
+        connection.get(rest_url, params)
       end
 
       def find_by_path(url, map={})
@@ -22,7 +28,7 @@ module Panda
         elsif object['id']
           kclass.new(object)
         else
-          Error.new(object).raise!
+          raise APIError.new(object)
         end
       end
 

data/lib/panda/modules/router.rb

@@ -1,6 +1,5 @@
 module Panda
   module Router
-    DEFAULT_FORMAT = "json"
     VAR_PATTERN = /:\w+/
 
     def self.included(base)
@@ -31,24 +30,31 @@ module Panda
         prefix_path + end_path
       end
 
-      def object_url(url, map)
-        full_object_url(url.clone.gsub(VAR_PATTERN){|key| map[key[1..-1].to_sym] || map[key[1..-1].to_s]})
+      def create_rest_url(url, map)
+        new_url = replace_pattern_with_variables(url, map)
+        json_path(new_url)
       end
+      
+      private
 
-      def element_params(url, map)
+      def replace_pattern_with_variables(url, map)
+        new_url = url.clone
+        new_url.gsub(VAR_PATTERN){|key| map[key[1..-1].to_sym] || map[key[1..-1].to_s]}
+      end
+      
+      def extract_unmapped_variables(url, map)
         params = map.clone
-        url.clone.scan(VAR_PATTERN).map{|key| params.reject!{|k,v| k==key[1..-1] } }
+        url.scan(VAR_PATTERN).map{|key| params.reject!{|k,v| k==key[1..-1] } }
         params
       end
 
-      def full_object_url(url)
-        url + ".#{DEFAULT_FORMAT}"
+      def json_path(uri)
+        uri + ".json"
       end
-
     end
 
-    def object_url_map(url)
-      self.class.full_object_url(url.clone.gsub(VAR_PATTERN) {|key| send(key[1..-1].to_sym)})
+    def replace_pattern_with_self_variables(url)
+      self.class.create_rest_url(url, attributes)
     end
 
   end