panda 0.6.4 → 1.0.0

data/lib/panda/modules/builders.rb

@@ -0,0 +1,34 @@
+module Panda
+  module Builders
+
+    def self.included(base)
+      base.extend(CreateBuilder)
+      base.extend(DeleteBuilder)
+    end
+
+    module CreateBuilder
+
+       def create(attributes)
+         if attr_id=(attributes[:id] || attributes['id'])
+           raise "Can't create attribute. Already have an id=#{attr_id}"
+         end
+
+         response = connection.post(full_object_url(many_path), attributes)
+         Panda::const_get("#{end_class_name}").new(response)
+       end
+
+       def create!(attributes)
+         create(attributes) || raise(self.error.first.to_s)
+       end
+
+    end
+
+    module DeleteBuilder
+      def delete(id)
+        response = connection.delete(full_object_url(object_url(one_path,{:id =>id})))
+        response['deleted'] == 'ok'
+      end
+    end
+
+  end
+end

data/lib/panda/modules/cloud_connection.rb

@@ -0,0 +1,7 @@
+module Panda
+  module CloudConnection
+    def connection
+      cloud.connection
+    end
+  end
+end

data/lib/panda/modules/finders.rb

@@ -0,0 +1,62 @@
+module Panda
+  module Finders
+
+    module FindOne
+
+      def find(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)
+      end
+
+      def find_by_path(url, map={})
+        object = find_object_by_path(url, map)
+        kclass = Panda::const_get("#{end_class_name}")
+
+        if object.is_a?(Array)
+          object.map{|o| kclass.new(o)}
+        elsif object["id"]
+          kclass.new(object)
+        else
+          Error.new(object).raise!
+        end
+      end
+
+    end
+
+    module FindMany
+
+      def find_by(map)
+        all(map).first
+      end
+
+      def all(map={})
+        find_by_path(many_path, map)
+      end
+
+      private
+
+      def find_all_by_has_many(relation_name, relation_value)
+         map = {}
+         map[relation_name.to_sym] = relation_value
+         has_many_path = build_hash_many_path(many_path, relation_name)
+         find_by_path(has_many_path, map)
+      end
+
+      def method_missing(method_symbol, *arguments)
+        method_name = method_symbol.to_s
+        if method_name =~ /^find_all_by_([_a-zA-Z]\w*)$/
+          find_all_by_has_many($1, arguments.pop)
+        else
+          super
+        end
+      end
+
+    end
+
+  end
+end

data/lib/panda/modules/router.rb

@@ -0,0 +1,55 @@
+module Panda
+  module Router
+    DEFAULT_FORMAT = "json"
+    VAR_PATTERN = /:\w+/
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def resource_path
+        @url || "/#{end_class_name.downcase}s"
+      end
+
+      def match(url)
+        @url = url
+      end
+
+      def many_path
+        resource_path
+      end
+
+      def one_path
+        resource_path + "/:id"
+      end
+
+      def build_hash_many_path(end_path, relation_attr)
+        relation_class_name = relation_attr[0..relation_attr.rindex("_id")-1].capitalize
+        prefix_path = Panda::const_get(relation_class_name).resource_path + "/:" + relation_attr
+        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]})
+      end
+
+      def element_params(url, map)
+        params = map.clone
+        url.clone.scan(VAR_PATTERN).map{|key| params.reject!{|k,v| k==key[1..-1] } }
+        params
+      end
+
+      def full_object_url(url)
+        url + ".#{DEFAULT_FORMAT}"
+      end
+
+    end
+
+    def object_url_map(url)
+      self.class.full_object_url(url.clone.gsub(VAR_PATTERN) {|key| send(key[1..-1].to_sym)})
+    end
+
+  end
+end

data/lib/panda/modules/short_status.rb

@@ -0,0 +1,13 @@
+module ShortStatus
+  def success?
+    @attributes['status'] == 'success'
+  end
+
+  def processing?
+    @attributes['status'] == 'processing'
+  end
+
+  def fail?
+    @attributes['status'] == 'fail'
+  end
+end

data/lib/panda/modules/updatable.rb

@@ -0,0 +1,27 @@
+module Panda
+  module Updatable
+
+    def save
+      new? ? create : update
+    end
+
+    def save!
+      save || raise("Resource invalid")
+    end
+
+    def update_attribute(name, value)
+      self.send("#{name}=".to_sym, value)
+      self.save
+    end
+
+    def update_attributes(attributes)
+      load(attributes) && save
+    end
+
+    def update
+      response = connection.put(object_url_map(self.class.one_path), @changed_attributes)
+      load_response(response) ? (@changed_attributes = {}; true) : false
+    end
+
+  end
+end

data/lib/panda/panda.rb

@@ -1,187 +1,38 @@
 require 'restclient'
+require 'forwardable'
 require 'json' unless defined?(ActiveSupport::JSON)
 
-class Panda
-  
-  def self.connect!(auth_params, options={})
-    @@connection = Connection.new(auth_params, options)
-  end
-  
-  def self.get(request_uri, params={})    
-    connection.get(request_uri, params)
-  end
+module Panda
+  class << self
+    extend Forwardable
 
-  def self.post(request_uri, params={})
-    connection.post(request_uri, params)
-  end
+    attr_reader :cloud, :clouds
+    attr_reader :connection
 
-  def self.put(request_uri, params={})
-    connection.put(request_uri, params)
-  end
+    def_delegators :connection, :get, :post, :put, :delete, :api_url, :setup_bucket, :signed_params
 
-  def self.delete(request_uri, params={})
-    connection.delete(request_uri, params)
-  end
-  
-  def self.setup_bucket(params={})
-    connection.setup_bucket(params)
-  end
-  
-  def self.authentication_params(*params)
-    raise "Method deprecated. Please use signed_params instead."
-  end
-  
-  def self.signed_params(verb, request_uri, params = {}, timestamp_str = nil)
-    connection.signed_params(verb, request_uri, params, timestamp_str)
-  end
-  
-  private 
-  
-  def self.connection
-    if defined?(@@connection)
-      @@connection
-    else
-      raise "Not connected. Please connect! first."
-    end
-  end
-  
-  class Connection
-    attr_reader :api_host, :api_port, :access_key, :secret_key, :api_version, :format
-  
-    DEFAULT_API_PORT=80
-    DEFAULT_API_HOST="api.pandastream.com"
-  
-    def initialize(auth_params, options={})
-      @api_version = 2
-      @format = "hash"
-      
-      if auth_params.class == String
-        self.format = options[:format] || options["format"]
-        init_from_url(auth_params)
-      else
-        self.format = auth_params[:format] || auth_params["format"]
-        init_from_hash(auth_params)
-      end
-      
-      @connection = RestClient::Resource.new(api_url)
-    end
-
-    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
-    
-    def get(request_uri, params={})
-      rescue_restclient_exception do
-        query = signed_query("GET", request_uri, params)
-        body_of @connection[request_uri + '?' + query].get
-      end
-    end
-
-    def post(request_uri, params={})
-      rescue_restclient_exception do
-        body_of @connection[request_uri].post(signed_params("POST", request_uri, params))
-      end
-    end
+    def configure(auth_params=nil)
+      @clouds = {}
 
-    def put(request_uri, params={})
-      rescue_restclient_exception do
-        body_of @connection[request_uri].put(signed_params("PUT", request_uri, params))
-      end
-    end
-
-    def delete(request_uri, params={})
-      rescue_restclient_exception do
-        query = signed_query("DELETE", request_uri, params)
-        body_of @connection[request_uri + '?' + query].delete
+      if auth_params
+        connect!(auth_params)
+      else
+        yield @connection = Connection.new
       end
-    end
 
-    def signed_query(*args)
-      ApiAuthentication.hash_to_query(signed_params(*args))
+      @connection.raise_error=true
+      @connection.format = :hash
+      @cloud = Cloud::new(:id => @connection.cloud_id)
     end
-    
-    def signed_params(verb, request_uri, params = {}, timestamp_str = nil)
-      auth_params = stringify_keys(params)
-      auth_params['cloud_id']   = @cloud_id
-      auth_params['access_key'] = @access_key
-      auth_params['timestamp']  = timestamp_str || Time.now.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)
-      auth_params
+    def connect!(auth_params, options={})
+      @connection = Connection.new(auth_params, options)
     end
 
-    def api_url
-      "http://#{@api_host}:#{@api_port}/#{@prefix}"
+    def connection
+      raise "Not connected. Please connect! first." unless @connection
+      @connection
     end
 
-    def setup_bucket(params={})
-      granting_params = { :s3_videos_bucket => params[:bucket], :user_aws_key => params[:access_key], :user_aws_secret => params[:secret_key] }
-      put("/clouds/#{@cloud_id}.json", granting_params)
-    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)
-        if self.format == "json"
-          response
-
-        elsif defined?(ActiveSupport::JSON)
-          ActiveSupport::JSON.decode(response)
-
-        else
-          JSON.parse(response)
-        end
-      end
-      
-      def init_from_url(url)
-        params = url.scan(/http:\/\/([^:@]+):([^:@]+)@([^:@]+)(:[\d]+)?\/([^:@]+)$/).flatten
-        @access_key = params[0]
-        @secret_key = params[1]
-        @cloud_id   = params[4]
-        @api_host   = params[2]
-
-        if params[3]
-          @api_port = params[3][1..-1]
-        else
-          @api_port = DEFAULT_API_PORT
-        end
-        @prefix     = "v#{@api_version}"
-
-      end
-
-      def init_from_hash(hash_params)
-        params      = { :api_host => DEFAULT_API_HOST, :api_port => DEFAULT_API_PORT }.merge(hash_params)
-
-        @cloud_id   = params["cloud_id"]    || params[:cloud_id]
-        @access_key = params["access_key"]  || params[:access_key]
-        @secret_key = params["secret_key"]  || params[:secret_key]
-        @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

data/lib/panda/proxies/encoding_scope.rb

@@ -0,0 +1,48 @@
+module Panda
+  class EncodingScope < Scope
+
+    def initialize(parent)
+      super(parent, Encoding)
+    end
+
+    def non_delegate_methods
+      super + [:status, :profile_id, :profile_name, :video, :page, :per_page]
+    end
+
+    def page(this_page)
+      @scoped_attributes[:page] = this_page
+      self
+    end
+
+    def per_page(this_per_page)
+      @scoped_attributes[:per_page] = this_per_page
+      self
+    end
+
+    def video(this_video_id)
+      @scoped_attributes[:video_id] = this_video_id
+      self
+    end
+
+    def status(this_status)
+      @scoped_attributes[:status] = this_status
+      self
+    end
+
+    def profile(this_profile_id)
+      @scoped_attributes[:profile_id] = this_profile_id
+      self
+    end
+
+    def profile_name(this_profile_name)
+      @scoped_attributes[:profile_name] = this_profile_name 
+      self
+    end
+
+    def find_by_profile_name(this_profile_name)
+      @scoped_attributes[:profile_name] = this_profile_name
+      trigger_request.first
+    end
+
+  end
+end