vj-sdk 0.2.1

data/lib/videojuicer/criterion/request.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), "base")
+
+module Videojuicer
+  module Criterion
+    class Request < Base
+      
+      property :referrer,           String, :nullable => false
+      property :exclude,            Boolean
+      
+      def matcher_keys
+        [:referrer, :exclude]
+      end
+    end
+  end
+end

data/lib/videojuicer/criterion/time.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), "base")
+
+module Videojuicer
+  module Criterion
+    class Time < Base
+      
+      property :until, DateTime
+      property :from, DateTime
+      
+      def matcher_keys
+        [:until, :from]
+      end
+    end
+  end
+end

data/lib/videojuicer/criterion/week_day.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), "base")
+
+module Videojuicer
+  module Criterion
+    class WeekDay < Base
+      property :monday,             Boolean
+      property :tuesday,            Boolean
+      property :wednesday,          Boolean
+      property :thursday,           Boolean
+      property :friday,             Boolean
+      property :saturday,           Boolean
+      property :sunday,             Boolean
+      property :exclude,            Boolean
+      
+      def matcher_keys
+        [:monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday, :exclude]
+      end
+    end
+  end
+end

data/lib/videojuicer/oauth/multipart_helper.rb

@@ -0,0 +1,96 @@
+# Cribbed almost entirely from Merb's multipart request helper.
+# Thanks, Yehuda!
+
+module Videojuicer
+  module OAuth
+    module Multipart
+  
+      require 'rubygems'
+      gem "mime-types"
+      require 'mime/types'
+
+      class Param
+        attr_accessor :key, :value
+
+        # ==== Parameters
+        # key<~to_s>:: The parameter key.
+        # value<~to_s>:: The parameter value.
+        def initialize(key, value)
+          @key   = key
+          @value = value
+        end
+
+        # ==== Returns
+        # String:: The parameter in a form suitable for a multipart request.
+        def to_multipart
+          return %(Content-Disposition: form-data; name="#{key}"\r\n\r\n#{value}\r\n)
+        end
+      end
+
+      class FileParam
+        attr_accessor :key, :filename, :content
+
+        # ==== Parameters
+        # key<~to_s>:: The parameter key.
+        # filename<~to_s>:: Name of the file for this parameter.
+        # content<~to_s>:: Content of the file for this parameter.
+        def initialize(key, filename, content)
+          @key      = key
+          @filename = filename
+          @content  = content
+        end
+
+        # ==== Returns
+        # String::
+        #   The file parameter in a form suitable for a multipart request.
+        def to_multipart
+          return %(Content-Disposition: form-data; name="#{key}"; filename="#{filename}"\r\n) + "Content-Type: #{MIME::Types.type_for(@filename).first}\r\n\r\n" + content + "\r\n"
+        end
+      end
+
+      class Post
+        BOUNDARY = '----------0xKhTmLbOuNdArY'
+        CONTENT_TYPE = "multipart/form-data, boundary=" + BOUNDARY
+
+        # ==== Parameters
+        # params<Hash>:: Optional params for the controller.
+        def initialize(params = {})
+          @multipart_params = []
+          push_params(params)
+        end
+
+        # Saves the params in an array of multipart params as Param and
+        # FileParam objects.
+        #
+        # ==== Parameters
+        # params<Hash>:: The params to add to the multipart params.
+        # prefix<~to_s>:: An optional prefix for the request string keys.
+        def push_params(params, prefix = nil)
+          params.sort_by {|k| k.to_s}.each do |key, value|
+            param_key = prefix.nil? ? key : "#{prefix}[#{key}]"
+            if value.respond_to?(:read)
+              @multipart_params << FileParam.new(param_key, value.path, value.read)
+              value.rewind
+            else
+              if value.is_a?(Hash) || value.is_a?(Mash)
+                value.keys.each do |k|
+                  push_params(value, param_key)
+                end
+              else
+                @multipart_params << Param.new(param_key, value)
+              end
+            end
+          end
+        end
+
+        # ==== Returns
+        # Array[String, String]:: The query and the content type.
+        def to_multipart
+          query = @multipart_params.collect { |param| "--" + BOUNDARY + "\r\n" + param.to_multipart }.join("") + "--" + BOUNDARY + "--"
+          return query, CONTENT_TYPE
+        end
+      end 
+    
+    end
+  end
+end

data/lib/videojuicer/oauth/proxy_factory.rb

@@ -0,0 +1,18 @@
+=begin rdoc
+  
+  ProxyFactory is a mixin that provides a convenience DSL for creating
+  new RequestProxy objects. It is intended for internal use within the SDK.
+
+=end
+
+module Videojuicer
+  module OAuth
+    module ProxyFactory
+      
+      def proxy_for(options={})
+        Videojuicer::OAuth::RequestProxy.new(options)
+      end
+      
+    end
+  end
+end

data/lib/videojuicer/oauth/request_proxy.rb

@@ -0,0 +1,280 @@
+=begin rdoc
+
+  The RequestProxy is, as the name suggests, a proxy through which HTTP requests are made
+  in order to have them correctly signed for verification under the OAuth protocol.
+  
+  More information on OAuth: http://oauth.net
+  
+  
+
+=end
+
+require 'cgi'
+require 'hmac'
+require File.join(File.dirname(__FILE__), 'multipart_helper')
+
+module Videojuicer
+  module OAuth
+
+    class RequestProxy
+      
+      # Requests to the following ports will not include the port in the signature base string.
+      # See OAuth spec 1.0a section 9.1.2 for details.
+      EXCLUDED_BASE_STRING_PORTS = [80, 443].freeze
+      
+      include Videojuicer::Exceptions
+      include Videojuicer::Configurable
+            
+      # Initializes a new RequestProxy object which can be used to make requests.
+      # Accepts all the same options as Videojuicer::configure! as well as:
+      # +token+ - The OAuth token to use in requests made through this proxy.
+      # +token_secret+ - The OAuth token secret to use when encrypting the request signature.
+      def initialize(options={})
+        configure!(options)
+      end
+      
+      # Makes a GET request given path and params.
+      # The host will be ascertained from the configuration options.
+      def get(path, params={}); make_request(:get, host, port, path, params); end
+      
+      # Makes a POST request given path and params.
+      # The host will be ascertained from the configuration options.
+      def post(path, params={}); make_request(:post, host, port, path, params); end
+      
+      # Makes a PUT request given path and params.
+      # The host will be ascertained from the configuration options.
+      def put(path, params={}); make_request(:put, host, port, path, params); end
+      
+      # Makes a DELETE request given path and params.
+      # The host will be ascertained from the configuration options.
+      def delete(path, params={}); make_request(:delete, host, port, path, params); end
+      
+      # Does the actual work of making a request. Returns a Net::HTTPResponse object.
+      def make_request(method, host, port, path, params={})
+        # Strip the files from the parameters to determine what, from the whole bundle, needs signing
+        signature_params, multipart_params = split_by_signature_eligibility(params)
+        
+        if multipart_params.any?
+          # Sign the params and include the as multipart
+          multipart_params = flatten_params(
+            authify_params(method, path, signature_params).deep_merge(multipart_params)
+          )
+          query_string = ""
+        else
+          # Use the query string
+          query_string = authified_query_string(method, path, signature_params)
+        end
+        
+        # Generate the HTTP Request and handle the response
+        url = "#{host_stub(protocol, host, port)}#{path}"
+        request = request_class_for_method(method).new("#{path}?#{query_string}")        
+        # Generate the multipart body and headers
+        if multipart_params.any?          
+          post_body, content_type = Multipart::Post.new(multipart_params).to_multipart
+          request.content_length = post_body.length
+          request.content_type = content_type
+          request.body = post_body
+        else
+          # Send a content-length on POST and PUT to avoid an HTTP 411 response
+          case method
+          when :post, :put
+            request = request_class_for_method(method).new("#{path}")
+            request.content_type = "application/x-www-form-urlencoded"
+            request.body = query_string
+            request.content_length = query_string.length
+          end
+        end
+        
+        
+        begin
+          #response = HTTPClient.send(method, url, multipart_params)
+          response = Net::HTTP.start(host, port) {|http| http.request(request) }
+        rescue EOFError => e
+          raise "EOF error when accessing #{url.inspect}"
+        rescue Errno::ECONNREFUSED => e
+          raise "Could not connect to #{url.inspect}"
+        end
+        
+        return handle_response(response, request)
+      end
+      
+      def host_stub(_protocol=protocol, _host=host, _port=port)
+        "#{_protocol}://#{_host}:#{_port}"
+      end
+      
+      # Handles an HTTPResponse object appropriately. Redirects are followed, 
+      # error states raise errors and success responses are returned directly.
+      def handle_response(response, request)
+        c = response.code.to_i
+        case c
+        when 200..399
+          # Successful or redirected response
+          response
+        when 415
+          # Validation error
+          response
+        when 401
+          # Authentication problem
+          response_error Unauthenticated, request, response
+        when 403
+          # Attempted to perform a forbidden action
+          response_error Forbidden, request, response
+        when 404
+          # Resource URL not valid
+          response_error NoResource, request, response
+        when 406
+          # Excuse me WTF r u doin
+          response_error NotAcceptable, request, response
+        when 411
+          # App-side server error where request is not properly constructed.
+          response_error ContentLengthRequired, request, response
+        when 500..600
+          # Remote application failure
+          response_error RemoteApplicationError, request, response
+        else
+          response_error UnhandledHTTPStatus, request, response
+        end
+      end
+      
+      # Handles the response as an error of the desired type.
+      def response_error(exception_klass, request, response)
+        begin
+          e = JSON.parse(response.body)
+          e = e["error"]
+          raise exception_klass, "#{e["message"]} \n #{(e["backtrace"] || []).join("\n")}"
+        rescue JSON::ParserError
+          raise exception_klass, "#{exception_klass.to_s} : Response code was #{response.code} for request: #{request.path}"
+        end
+        
+      end
+      
+      # Splits a given parameter hash into two hashes - one containing all
+      # string and non-binary parameters, and one containing all file/binary parameters.
+      # This action is performed recursively so that:
+      #   params = {:user=>{:attributes=>{:file=>some_file, :name=>"user name"}}, :foo=>"bar"}
+      #   normal, multipart = split_multipart_params(params)
+      #   normal.inspect # => {:user=>{:attributes=>{:name=>"user name"}}, :foo=>"bar"}
+      #   multipart.inspect # => {:user=>{:attributes=>{:file=>some_file}}}
+      def split_by_signature_eligibility(params, *hash_path)
+        strings = {}
+        files = {}
+        params.each do |key, value|
+          if value.is_a?(Hash)
+            # Call recursively
+            s, f = split_by_signature_eligibility(value, *(hash_path+[key]))
+            strings = strings.deep_merge(s)
+            files = files.deep_merge(f)
+          else 
+            # Insert it into files at the current key path if it is a binary,
+            # and into strings if it is not.
+            pwd = (value.respond_to?(:read))? files : strings
+            hash_path.each do |component|
+              pwd[component] ||= {}
+              pwd = pwd[component]
+            end
+            pwd[key] = value
+          end
+        end
+        return strings, files
+      end
+      
+      def signed_url(method, path, params={})
+        "#{protocol}://#{host}:#{port}#{path}?#{authified_query_string(method, path, params)}"
+      end
+      
+      # Authifies the given parameters and converts them into a query string.
+      def authified_query_string(method, path, params={})
+        normalize_params(authify_params(method, path, params))
+      end
+      
+      # Takes a set of business parameters you want sent to the provider, and merges them
+      # with the proxy configuration to produce a set of parameters that will be accepted
+      # by the OAuth provider.
+      def authify_params(method, path, params)
+        params = {
+          :oauth_consumer_key=>consumer_key,
+          :oauth_token=>token,
+          :api_version=>api_version,
+          :oauth_timestamp=>Time.now.to_i,
+          :oauth_nonce=>rand(9999),
+          :oauth_signature_method=>"HMAC-SHA1",
+          :seed_name=>seed_name,
+          :user_id=>user_id
+        }.merge(params)
+        params.delete_if {|k,v| (!v) or (v.to_s.empty?) }
+        params[:oauth_signature] = signature(method, path, params)
+        return params
+      end
+      
+      # Calculates and returns the encrypted signature for this proxy object and the
+      # given request properties.
+      def signature(method, path, params)
+        base = signature_base_string(method, path, params)
+        signature_octet = HMAC::SHA1.digest(signature_secret, base)
+        signature_base64 = [signature_octet].pack('m').chomp.gsub(/\n/, '')
+      end
+      
+      # Calculates and returns the signature secret to be used for this proxy object.
+      def signature_secret
+        [consumer_secret, token_secret].collect {|e| CGI.rfc3986_escape(e.to_s)}.join("&")
+      end
+      
+      # Returns the unencrypted signature base string for this proxy object and the 
+      # given request properties.
+      def signature_base_string(method, path, params)
+        s = [method.to_s.upcase, "#{protocol}://#{signature_base_string_host}#{path}", normalize_params(params)].collect {|e| CGI.rfc3986_escape(e)}.join("&")
+      end
+      
+      def signature_base_string_host
+        if EXCLUDED_BASE_STRING_PORTS.include?(port.to_i)
+          # Natural port. Ignore the port
+          host
+        else
+          # Weird port. Expect a signature.
+          "#{host}:#{port}"
+        end
+      end
+      
+      # Returns a string representing a normalised parameter hash. Supports nesting for
+      # rails or merb-style object[attr] properties supplied as nested hashes. For instance,
+      # the key 'bar inside {:foo=>{:bar=>"baz"}} will be named foo[bar] in the signature
+      # and in the eventual request object.
+      def normalize_params(params, *hash_path)
+        flatten_params(params).sort {|a,b| a.to_s <=> b.to_s}.collect {|k, v| "#{CGI.rfc3986_escape(k)}=#{CGI.rfc3986_escape(v.to_s)}" }.join("&")
+      end
+      
+      def flatten_params(params, *hash_path)
+        op = {}
+        params.sort {|a,b| a.to_s<=>b.to_s}.each do |key, value|
+          path = hash_path.dup
+          path << key.to_s
+          
+          if value.is_a?(Hash)
+            op.merge! flatten_params(value, *path)
+          elsif value
+            key_path = path.first + path[1..(path.length-1)].collect {|h| "[#{h}]"}.join("")
+            op[key_path] = value
+          end
+        end
+        return op
+      end
+      
+      # Returns the Net::HTTPRequest subclass needed to make a request for the given method.
+      def request_class_for_method(m, in_module=Net::HTTP)
+        case (m.is_a?(Symbol) ? m : m.downcase.to_sym rescue :get)
+        when :post
+          in_module::Post
+        when :put
+          in_module::Put
+        when :head
+          in_module::Head
+        when :delete
+          in_module::Delete
+        else
+          in_module::Get
+        end
+      end
+      
+    end
+  end
+end

data/lib/videojuicer/presentation.rb

@@ -0,0 +1,38 @@
+module Videojuicer
+  class Presentation
+    include Videojuicer::Resource
+    include Videojuicer::Resource::Embeddable
+    include Videojuicer::Exceptions
+    
+    property :slug,               String
+    property :title,              String
+    property :author,             String
+    property :author_url,         String
+    property :abstract,           String
+    property :user_id,            Integer,  :writer=>:private
+      belongs_to :user, :class=>Videojuicer::User
+    property :callback_url,       String
+
+    property :state,              String,   :default=>"ready" # see the STATES constant for values
+    property :disclosure,         String,   :default=>"public" # see DISCLOSURES constant for values
+    property :publish_from,       DateTime
+    property :publish_until,      DateTime
+
+    property :document_layout,    String
+    property :document_content,   String # the presentation document
+    property :document_type,      String, :default=>"SMIL 3.0"
+
+    property :created_at,         DateTime
+    property :updated_at,         DateTime
+
+    property :image_asset_id,     Integer # FIXME make me a relationship helper
+
+    property :tag_list,           String
+   
+    def permalink
+      proxy = proxy_for(config)
+      "#{proxy.host_stub}/presentations/#{id}.html?seed_name=#{seed_name}".gsub(":80/","/")
+    end
+   
+  end 
+end

data/lib/videojuicer/preset.rb

@@ -0,0 +1,29 @@
+module Videojuicer
+  class Preset
+    include Videojuicer::Resource
+    
+    property :name,              String
+    property :derived_type,      String
+    property :created_at,        DateTime
+    property :updated_at,        DateTime
+
+    property :file_format,       String
+
+    property :audio_bit_rate,    Integer  # bits per second
+    property :audio_channels,    Integer
+    property :audio_format,      String
+    property :audio_sample_rate, Integer  # hertz
+
+    property :video_bit_rate,    Integer  # bits per second
+    property :video_format,      String
+    property :video_frame_rate,  Float    # frames per second
+
+    property :width,             Integer  # pixels
+    property :height,            Integer  # pixels
+    
+    def self.formats
+      response = instance_proxy.get(resource_route(:formats))
+      JSON.parse(response.body)
+    end
+  end
+end

data/lib/videojuicer/promo/base.rb

@@ -0,0 +1,72 @@
+module Videojuicer
+  module Promo
+    def self.model_map
+      { :audio  => Videojuicer::Promo::Audio,
+        :images => Videojuicer::Promo::Image,
+        :texts  => Videojuicer::Promo::Text,
+        :videos => Videojuicer::Promo::Video
+      }
+    end
+    
+    class Base
+      
+      def self.inherited(base)
+        base.send(:include, Videojuicer::Resource)
+        base.send(:extend, Videojuicer::Promo::Base::ClassMethods)
+        base.send(:include, Videojuicer::Promo::Base::InstanceMethods)
+        
+        base.property :campaign_policy_id,  Integer
+        base.property :asset_id,            Integer
+        base.property :role,                String
+        base.property :href,                String
+      end
+      
+      module ClassMethods
+        def singular_name
+          "promo"
+        end
+        
+        def base_path(options={})
+          "/promos/#{self.to_s.split("::").last.snake_case}"
+        end
+        
+        def get(*args); raise NoMethodError; end
+        def all(*args); raise NoMethodError; end
+        def first(*args); raise NoMethodError; end
+      end
+      
+      module InstanceMethods
+        def save(*args); raise NoMethodError; end
+        def destroy(*args); raise NoMethodError; end
+        def asset
+          Videojuicer::Asset.const_get(self.class.to_s.split("::").last).get(asset_id)
+        end
+        def matcher_keys
+          [:campaign_policy_id, :asset_id, :role, :href]
+        end
+        def matcher_attributes
+          matcher_keys.inject({}) do |memo, attr|
+            memo.update(attr => self.send(attr))
+          end
+        end
+      end
+            
+    end
+    
+    class Audio < Base
+    end
+
+    class Image < Base
+    end
+
+    class Text < Base
+    end
+    
+    class Video < Base
+    end
+    
+    class Heart < Base
+    end
+    
+  end
+end