videojuicer-vj-sdk 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 danski
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,7 @@
+= vj-sdk
+
+Description goes here.
+
+== Copyright
+
+Copyright (c) 2009 danski. See LICENSE for details.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 0

data/lib/core_ext/hash.rb

@@ -0,0 +1,40 @@
+class Hash
+
+  # Returns a new hash just like this one, but with all the string keys expressed as symbols.
+  # Also applies to hashes within self.
+  # Based on an implementation within Rails 2.x, thanks Rails!
+  def deep_symbolize
+    target = dup    
+    target.inject({}) do |memo, (key, value)|
+      value = value.deep_symbolize if value.is_a?(Hash)
+      memo[(key.to_sym rescue key) || key] = value
+      memo
+    end
+  end
+    
+  # Merges self with another hash, recursively.
+  # 
+  # This code was lovingly stolen from some random gem:
+  # http://gemjack.com/gems/tartan-0.1.1/classes/Hash.html
+  # 
+  # Thanks to whoever made it.
+  def deep_merge(hash)
+    target = dup
+    
+    hash.keys.each do |key|
+      if hash[key].is_a? Hash and self[key].is_a? Hash
+        target[key] = target[key].deep_merge(hash[key])
+        next
+      end      
+      target[key] = hash[key]
+    end    
+    target
+  end
+  
+  def to_xml
+    inject("") do |memo, (key, value)|
+      memo << "<#{key}>#{(value.respond_to?(:to_xml))? value.to_xml : value}</#{key}>"
+    end
+  end
+
+end

data/lib/sdk_connection_harness.rb

@@ -0,0 +1,87 @@
+require 'mash'
+require 'yaml'
+class SDKConnectionHarness
+  class << self
+
+    attr_accessor :server_pid
+    attr_accessor :fixtures
+
+    def core_directory
+      File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "vj-core"))
+    end
+    
+    def start!
+      stop! if running?
+      puts "Starting vj-core from #{core_directory}\n"
+      Thread.new do
+        cur_dir = Dir.pwd
+        Dir.chdir(core_directory) do
+          `merb -d -p #{port} -e test --log .log/sdk-development.log`
+        end
+        Dir.chdir(cur_dir)
+      end
+    end
+    
+    def stop!
+      Thread.new do
+        `killall -9 "merb : worker (port #{port})"`
+      end
+    end
+    
+    def running?
+      uri = URI.parse("http://localhost:#{port}/")
+      req = Net::HTTP::Get.new(uri.path)
+      
+      begin
+        resp = Net::HTTP.start(uri.host, uri.port) do |http|
+          http.request(req)
+        end
+        return true
+      rescue Exception => e
+        # Connection refused means the daemon isn't running
+        return false
+      end
+    end
+    
+    def load_fixtures
+      Dir.chdir(core_directory) do
+        out = `rake videojuicer:sdk:setup MERB_ENV=test`
+        out = out.match(/!!!([^!]+)!!!/m)
+        self.fixtures = out[1]
+      end
+    end
+    
+    def write_fixtures
+      f = File.open(File.join(File.dirname(__FILE__), "..", "core-fixtures.yml"), "w+")
+      f.rewind
+      f.write(self.fixtures)
+      f.close
+    end
+    
+    def port
+      5555
+    end
+    
+    def connect(overrides={})
+      fixtures = Mash.new(YAML.load(load_fixtures)).merge(overrides)
+      configure_test_settings(overrides)
+      Videojuicer.enter_scope :seed_name => fixtures.seed.name, 
+                              :consumer_key=>fixtures["write-master"].consumer.consumer_key,
+                              :consumer_secret=>fixtures["write-master"].consumer.consumer_secret,
+                              :token=>fixtures["write-master"].authorized_token.oauth_token,
+                              :token_secret=>fixtures["write-master"].authorized_token.oauth_token_secret
+    end
+    
+    def configure_test_settings(overrides={})
+      Videojuicer.configure!({
+        :consumer_key     => nil,
+        :consumer_secret  => nil,
+        :api_version      => 1,
+        :protocol         => "http",
+        :host             => "localhost",
+        :port             => 5555
+      }.merge(overrides))
+    end
+    
+  end
+end

data/lib/videojuicer/asset/audio.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), "base")
+
+module Videojuicer
+  module Asset
+    class Audio < Base
+      
+      property :bit_rate, Integer
+      
+    end
+  end
+end

data/lib/videojuicer/asset/base.rb

@@ -0,0 +1,50 @@
+module Videojuicer
+  module Asset
+    class Base
+      
+      def self.inherited(base)
+        base.send(:include, Videojuicer::Resource)
+        base.send(:extend, Videojuicer::Asset::Base::ClassMethods)
+        base.send(:include, Videojuicer::Asset::Base::InstanceMethods)
+        
+        base.property :user_id,         Integer
+        # - generic file handling
+        base.property :file,            File
+        base.property :file_name,       String
+        base.property :file_size,       Integer, :writer=>:private
+        # - common metadata
+        base.property :duration,        Integer # milliseconds
+        base.property :licensed_at,     Date
+        base.property :licensed_by,     String
+        base.property :licensed_under,  String
+        base.property :published_at,    Date
+        # - access control / workflow
+        base.property :disclosure,      String
+        base.property :state,           String, :writer => :private
+        base.property :url,             String, :writer => :private
+        
+        base.property :created_at,      DateTime
+        base.property :updated_at,      DateTime
+      end
+      
+      module ClassMethods
+        def singular_name
+          "asset"
+        end
+        
+        def base_path
+          "/assets/#{self.to_s.downcase.split("::").last}"
+        end
+      end
+      
+      module InstanceMethods
+        def returnable_attributes
+          attrs = super
+          attrs.delete(:file) unless new_record?
+          attrs
+        end
+      end
+      
+    end
+  end
+end

data/lib/videojuicer/asset/image.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), "base")
+
+module Videojuicer
+  module Asset
+    class Image < Base
+      
+      property :width,    Integer # pixels
+      property :height,   Integer # pixels
+      
+    end
+  end
+end

data/lib/videojuicer/asset/text.rb

@@ -0,0 +1,8 @@
+require File.join(File.dirname(__FILE__), "base")
+
+module Videojuicer
+  module Asset
+    class Text < Base
+    end
+  end
+end

data/lib/videojuicer/asset/video.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), "base")
+
+module Videojuicer
+  module Asset
+    class Video < Base
+      
+      property :width,    Integer # pixels
+      property :height,   Integer # pixels
+      property :bit_rate, Integer # bits per second
+      
+    end
+  end
+end

data/lib/videojuicer/campaign.rb

@@ -0,0 +1,8 @@
+module Videojuicer
+  class Campaign
+    include Videojuicer::Resource
+    include Videojuicer::Exceptions
+    
+    property :name, String
+  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,234 @@
+=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
+      
+      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 = "#{protocol}://#{host}:#{port}#{path}?#{query_string}"
+        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
+        end
+        
+        begin
+          #response = HTTPClient.send(method, url, multipart_params)
+          response = Net::HTTP.start(host, port) {|http| http.request(request) }
+        rescue Errno::ECONNREFUSED => e
+          raise "Could not connect to #{url.inspect}"
+        end
+        
+        return handle_response(response, request)
+      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 415
+          response
+        when 403
+          response_error Forbidden, response
+        when 400..499
+          response_error NoResource, response
+        when 500..600
+          response_error RemoteApplicationError, response
+        else
+          response
+        end
+      end
+      
+      # Handles the response as an error of the desired type.
+      def response_error(exception_klass, 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
+        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.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}://#{host}#{path}", normalize_params(params)].collect {|e| CGI.escape(e)}.join("&")
+      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.escape(k)}=#{CGI.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,32 @@
+module Videojuicer
+  class Presentation
+    include Videojuicer::Resource
+    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
+   
+  end 
+end