panda 0.6.4 → 1.0.0

data/Rakefile

@@ -10,10 +10,7 @@ begin
     gem.email = "info@pandastream.com"
     gem.homepage = "http://github.com/newbamboo/panda_gem"
     gem.authors = ["New Bamboo"]
-    gem.add_development_dependency "rspec", ">= 1.2.9"
-    gem.add_development_dependency "webmock"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-    gem.add_dependency "ruby-hmac", ">= 0.3.2" 
+    gem.add_dependency "ruby-hmac", ">= 0.3.2"
     gem.add_dependency "rest-client", ">= 1.4"
     gem.add_dependency "json", ">= 1.2"
   end
@@ -22,19 +19,9 @@ rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-  spec.ruby_opts = ['-rrubygems']
+desc "Run all the specs"
+task :spec do
+  system "bundle exec spec -O spec/spec.opts spec"
 end
 
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
-
-task :spec => :check_dependencies
-
 task :default => :spec

data/VERSION

@@ -1 +1 @@
-0.6.4
+1.0.0

data/lib/panda.rb

@@ -1,2 +1,22 @@
 require 'panda/api_authentication'
-require 'panda/panda'
+require 'panda/connection'
+require 'panda/modules/router'
+require 'panda/modules/finders'
+require 'panda/modules/builders'
+require 'panda/modules/associations'
+require 'panda/modules/updatable'
+require 'panda/modules/short_status'
+require 'panda/modules/cloud_connection'
+require 'panda/proxies/proxy'
+require 'panda/proxies/scope'
+require 'panda/proxies/encoding_scope'
+require 'panda/proxies/video_scope'
+require 'panda/proxies/profile_scope'
+require 'panda/error'
+require 'panda/base'
+require 'panda/resources/resource'
+require 'panda/resources/cloud'
+require 'panda/resources/encoding'
+require 'panda/resources/profile'
+require 'panda/resources/video'
+require 'panda/panda'

data/lib/panda/api_authentication.rb

@@ -5,19 +5,19 @@ require 'hmac'
 require 'hmac-sha2'
 require 'base64'
 
-class Panda
+module Panda
   class ApiAuthentication
     def self.generate_signature(verb, request_uri, host, secret_key, params_given={})
       # Ensure all param keys are strings
       params = {}; params_given.each {|k,v| params[k.to_s] = v }
-      
+
       query_string = canonical_querystring(params)
-      
+
       string_to_sign = verb.to_s.upcase + "\n" + 
           host.downcase + "\n" +
           request_uri + "\n" +
           query_string
-      
+
       hmac = HMAC::SHA256.new( secret_key )
       hmac.update( string_to_sign )
       # chomp is important!  the base64 encoded version will have a newline at the end

data/lib/panda/base.rb

@@ -0,0 +1,102 @@
+module Panda
+  class Base    
+    attr_accessor :attributes, :errors
+    include Panda::Router
+
+    def initialize(attributes = {})
+      init_load
+      load(attributes)
+    end
+
+    class << self
+      def id(this_id)
+        find(this_id)
+      end
+
+      def end_class_name
+        "#{name.split('::').last}"
+      end
+    end
+
+    def changed?
+      !@changed_attributes.empty?
+    end
+
+    def new?
+      id.nil?
+    end
+
+    def delete
+      response = connection.delete(object_url_map(self.class.one_path))
+      !!response['deleted']
+    end
+
+    def id
+      attributes['id']
+    end
+
+    def id=(id)
+      attributes['id'] = id
+    end
+
+    def reload
+      perform_reload
+      self
+    end
+
+    def to_json
+      attributes.to_json
+    end
+
+    private
+
+    def perform_reload(args={})
+      raise "RecordNotFound" if new?
+
+      url = self.class.object_url(self.class.one_path, :id => id)
+      response = connection.get(url)
+      init_load
+      load_response(response.merge(args))
+    end
+
+    def init_load
+      @attributes = {}
+      @changed_attributes = {}
+      @errors = []
+    end
+
+    def load(attributes)
+      attributes.each do |key, value|
+        @attributes[key.to_s] = value
+        @changed_attributes[key.to_s] = value if !(attributes['id'] || attributes[:id])
+      end
+      true
+    end
+
+    def load_response(response)
+      if response['error'] || response['id'].nil?
+        !(@errors << Error.new(response))
+      else
+        @errors=[]
+        load(response)
+      end
+    end
+
+    def method_missing(method_symbol, *arguments)
+      method_name = method_symbol.to_s
+      if method_name =~ /(=|\?)$/
+        case $1
+        when '='
+          attributes[$`] = arguments.first
+          @changed_attributes[$`] = arguments.first
+        when '?'
+          !! attributes[$`]
+        end
+      else
+        return attributes[method_name] if attributes.include?(method_name)
+        super
+      end
+    end
+
+  end
+end

data/lib/panda/connection.rb

@@ -0,0 +1,189 @@
+module Panda
+  class Connection
+    attr_accessor :api_host, :api_port, :access_key, :secret_key, :api_version, :cloud_id, :format
+
+    API_PORT=80
+    US_API_HOST="api.pandastream.com"
+    EU_API_HOST="api.eu.pandastream.com"
+
+    def initialize(auth_params={}, options={})
+      @raise_error = false
+      @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)
+    end
+
+    # Raise exception on non JSON parsable response if set
+    def raise_error=(bool)
+      @raise_error = bool
+    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
+    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
+    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
+    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
+    end
+
+    # Signing methods
+    def signed_query(*args)
+      ApiAuthentication.hash_to_query(signed_params(*args))
+    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
+    end
+
+    def api_url
+      "http://#{@api_host}:#{@api_port}/#{@prefix}"
+    end
+
+    # Shortcut to setup your bucket
+    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
+
+    def to_hash
+      hash = {}
+      [:api_host, :api_port, :access_key, :secret_key, :api_version, :cloud_id].each do |a|
+        hash[a] = send(a)
+      end
+      hash
+    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}"
+      end
+
+      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]
+        @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/error.rb

@@ -0,0 +1,29 @@
+module Panda
+  class Error
+    attr_reader :message
+    attr_reader :error_class
+    attr_reader :original_hash
+
+    def initialize(options)
+     @original_hash = options
+     @message = options['message']
+     @error_class = options['error']
+    end
+
+    def raise!
+      raise(self.to_s)
+    end
+
+    def to_s
+      "#{@error_class}: #{@message}"
+    end
+
+  end
+
+  class ServiceNotAvailable < StandardError
+    def initialize
+      super("ServiceNotAvailable")
+    end
+  end
+
+end

data/lib/panda/modules/associations.rb

@@ -0,0 +1,55 @@
+module Panda
+  module Associations
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def has_one(relation_name)
+        # for example creates : @video ||= VideoScope.new(self)
+
+        define_method relation_name do
+          param_id = "#{relation_name}_id"
+          if instance_var = instance_variable_get("@#{relation_name}")
+            instance_var
+          else
+            @associations ||= []
+            @associations << relation_name
+            instance_variable_set("@#{relation_name}",
+              Panda::const_get(relation_name.to_s.capitalize).find(send(param_id.to_sym)))
+          end
+        end
+      end
+
+      def has_many(relation_name)
+        # for example creates : @encodings ||= EncodingScope.new(self)
+
+        define_method relation_name do
+          model_name = "#{relation_name.to_s[0..-2].capitalize}"
+          if instance_var = instance_variable_get("@#{relation_name}")
+            instance_var
+          else
+            @associations ||= []
+            @associations << relation_name
+            instance_variable_set("@#{relation_name}",
+              Panda::const_get("#{model_name}Scope").new(self))
+          end
+        end
+      end
+
+      alias :belongs_to :has_one
+
+    end
+
+    private
+    def reset_associations
+      if @associations
+        @associations.each do |a|
+          instance_variable_set("@#{a}",nil)
+        end
+      end
+    end
+
+  end
+end