animoto 0.0.0.alpha3 → 0.0.0.alpha4

data/lib/animoto/asset.rb

@@ -15,11 +15,5 @@ module Animoto
       { 'source' => @source }
     end
     
-    # Returns a representation of this asset as JSON.
-    #
-    # @return [String] this asset as JSON
-    def to_json
-      self.to_hash.to_json
-    end
   end
 end

data/lib/animoto/client.rb

@@ -1,8 +1,5 @@
-require 'uri'
-require 'net/http'
-require 'net/https'
-require 'json'
 require 'yaml'
+require 'uri'
 
 require 'animoto/errors'
 require 'animoto/content_type'
@@ -25,19 +22,18 @@ require 'animoto/job'
 require 'animoto/directing_and_rendering_job'
 require 'animoto/directing_job'
 require 'animoto/rendering_job'
+require 'animoto/dynamic_class_loader'
+require 'animoto/http_engine'
+require 'animoto/response_parser'
 
 module Animoto
   class Client
     API_ENDPOINT      = "https://api2-staging.animoto.com/"
     API_VERSION       = 1
     BASE_CONTENT_TYPE = "application/vnd.animoto"
-    HTTP_METHOD_MAP   = {
-      :get  => Net::HTTP::Get,
-      :post => Net::HTTP::Post
-    }
     
     attr_accessor :key, :secret, :endpoint
-    attr_reader   :format
+    attr_reader :http_engine, :response_parser
     
     # Creates a new Client object which handles credentials, versioning, making requests, and
     # parsing responses.
@@ -52,27 +48,61 @@ module Animoto
     # @return [Client]
     # @raise [ArgumentError] if no credentials are supplied
     def initialize *args
-      @debug = ENV['DEBUG']
       options = args.last.is_a?(Hash) ? args.pop : {}
       @key = args[0]
       @secret = args[1]
       @endpoint = options[:endpoint]
-
-      home_path = File.expand_path '~/.animotorc'
-      config = if File.exist?(home_path)
-        YAML.load(File.read(home_path))
-      elsif File.exist?('/etc/.animotorc')
-        YAML.load(File.read('/etc/.animotorc'))
+      configure_from_rc_file
+      @endpoint ||= API_ENDPOINT
+      __send__ :http_engine=, options[:http_engine] || :net_http
+      __send__ :response_parser=, options[:response_parser] || :json
+    end
+    
+    # Set the HTTP engine this client will use.
+    # 
+    # @param [HTTPEngine, Symbol, Class] engine you may pass a
+    #   HTTPEngine instance to use, or the symbolic name of a adapter to use,
+    #   or a Class whose instances respond to #request and return a String of
+    #   the response body
+    # @see Animoto::HTTPEngine
+    # @return [HTTPEngine] the engine instance
+    # @raise [ArgumentError] if given a class without the correct interface
+    def http_engine= engine
+      @http_engine = case engine
+      when Animoto::HTTPEngine
+        engine
+      when Class
+        if engine.instance_methods.include?('request')
+          engine.new
+        else
+          raise ArgumentError
+        end
+      else
+        Animoto::HTTPEngine[engine].new
       end
-        @key ||= config['key']
-        @secret ||= config['secret']
-        @endpoint ||= config['endpoint']
-      unless @key && @secret
-        raise ArgumentError, "You must supply your key and secret"
+    end
+    
+    # Set the response parser this client will use.
+    # 
+    # @param [ResponseParser, Symbol, Class] parser you may pass a
+    #   ResponseParser instance to use, or the symbolic name of a adapter to use,
+    #   or a Class whose instances respond to #parse, #unparse, and #format.
+    # @see Animoto::ResponseParser
+    # @return [ResponseParser] the parser instance
+    # @raise [ArgumentError] if given a class without the correct interface
+    def response_parser= parser
+      @response_parser = case parser
+      when Animoto::ResponseParser
+        parser
+      when Class
+        if %{format parse unparse}.all? { |m| parser.instance_methods.include? m }
+          parser.new
+        else
+          raise ArgumentError
+        end
+      else
+        Animoto::ResponseParser[parser].new
       end
-
-      @endpoint ||= API_ENDPOINT
-      @format = 'json'
     end
     
     # Finds a resource by its URL.
@@ -124,15 +154,40 @@ module Animoto
     
     private
     
+    # Sets the API credentials from an .animotorc file. First looks for one in the current
+    # directory, then checks ~/.animotorc, then finally /etc/.animotorc.
+    #
+    # @raise [ArgumentError] if none of the files are found
+    def configure_from_rc_file
+      catch(:done) do
+        current_path = Dir.pwd + '/.animotorc'
+        home_path    = File.expand_path('~/.animotorc')
+        config = if File.exist?(current_path)
+          YAML.load(File.read(current_path))
+        elsif File.exist?(home_path)
+          home_path = File.expand_path '~/.animotorc'
+          YAML.load(File.read(home_path))
+        elsif File.exist?('/etc/.animotorc')
+          YAML.load(File.read('/etc/.animotorc'))
+        end
+        if config
+          @key      ||= config['key']
+          @secret   ||= config['secret']
+          @endpoint ||= config['endpoint']
+          throw :done if @key && @secret
+        end
+        raise ArgumentError, "You must supply your key and secret"
+      end
+    end
+
     # Builds a request to find a resource.
     #
     # @param [Class] klass the Resource class you're looking for
     # @param [String] url the URL of the resource
     # @param [Hash] options
-    # @return [Hash] deserialized JSON response body
+    # @return [Hash] deserialized response body
     def find_request klass, url, options = {}
-      # request(:get, URI.parse(url).path, nil, { "Accept" => content_type_of(klass) }, options)
-      request(:get, URI.parse(url), nil, { "Accept" => content_type_of(klass) }, options)
+      request(:get, url, nil, { "Accept" => content_type_of(klass) }, options)
     end
     
     # Builds a request requiring a manifest.
@@ -140,104 +195,43 @@ module Animoto
     # @param [Manifest] manifest the manifest being acted on
     # @param [String] endpoint the endpoint to send the request to
     # @param [Hash] options
-    # @return [Hash] deserialized JSON response body
+    # @return [Hash] deserialized response body
     def send_manifest manifest, endpoint, options = {}
-      # request(:post, endpoint, manifest.to_json, { "Accept" => "application/#{format}", "Content-Type" => content_type_of(manifest) }, options)
       u = URI.parse(endpoint)
       u.path = endpoint
-      request(:post, u, manifest.to_json, { "Accept" => "application/#{format}", "Content-Type" => content_type_of(manifest) }, options)
+      request(
+        :post,
+        u.to_s,
+        response_parser.unparse(manifest.to_hash),
+        { "Accept" => "application/#{response_parser.format}", "Content-Type" => content_type_of(manifest) },
+        options
+      )
     end
     
     # Makes a request and parses the response.
     #
     # @param [Symbol] method which HTTP method to use (should be lowercase, i.e. :get instead of :GET)
-    # @param [URI] uri a URI object of the request URI
+    # @param [String] url the URL of the request
     # @param [String, nil] body the request body
     # @param [Hash<String,String>] headers the request headers (will be sent as-is, which means you should
     #   specify "Content-Type" => "..." instead of, say, :content_type => "...")
     # @param [Hash] options
-    # @return [Hash] deserialized JSON response body
-    def request method, uri, body, headers = {}, options = {}
-      http = Net::HTTP.new uri.host, uri.port
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      req = build_request method, uri, body, headers, options
-      if @debug
-        puts "********************* REQUEST  *******************"
-        puts "#{req.method} #{uri.to_s} HTTP/#{http.instance_variable_get(:@curr_http_version)}\r\n"
-        req.each_capitalized { |header, value| puts "#{header}: #{value}\r\n" }
-        puts "\r\n"
-        puts req.body unless req.method == 'GET'
+    # @return [Hash] deserialized response body
+    # @raise [Error]
+    def request method, url, body, headers = {}, options = {}
+      error = catch(:fail) do
+        options = { :username => @key, :password => @secret }.merge(options)
+        response = http_engine.request(method, url, body, headers, options)
+        return response_parser.parse(response)
       end
-      response = http.request(req)
-      if @debug
-        puts "********************* RESPONSE *******************"
-        puts "#{response.code} #{response.message}\r\n"
-        response.each_capitalized { |header, value| puts "#{header}: #{value}\r\n" }
-        puts "\r\n"
-        body = response.body
-        if body.nil? || body.empty?
-          puts "(No content)"
-        else
-          puts body
-        end
+      if error
+        errors = response_parser.parse(error)['response']['status']['errors']
+        raise Animoto::Error.new(errors.collect { |e| e['message'] }.join(', '))
+      else
+        raise Animoto::Error
       end
-      read_response response
-    end
-    
-    # Builds the request object.
-    #
-    # @param [Symbol] method which HTTP method to use (should be lowercase, i.e. :get instead of :GET)
-    # @param [String] uri the request path
-    # @param [String, nil] body the request body
-    # @param [Hash<String,String>] headers the request headers (will be sent as-is, which means you should
-    #   specify "Content-Type" => "..." instead of, say, :content_type => "...")
-    # @param [Hash] options
-    # @return [Net::HTTPRequest] the request object
-    def build_request method, uri, body, headers, options
-      req = HTTP_METHOD_MAP[method].new uri.path
-      req.body = body
-      req.initialize_http_header headers
-      req.basic_auth key, secret
-      req
-    end
-
-    # Verifies and parses the response.
-    #
-    # @param [Net::HTTPResponse] response the response object
-    # @return [Hash] deserialized JSON response body
-    def read_response response
-      check_status response
-      parse_response response
-    end
-    
-    # Checks the status of the response to make sure it's successful.
-    #
-    # @param [Net::HTTPResponse] response the response object
-    # @return [nil]
-    # @raise [Error,RuntimeError] if the response code isn't in the 200 range
-    def check_status response
-      unless (200..299).include?(response.code.to_i)
-        if response.body
-          begin
-            json = JSON.parse(response.body)
-            errors = json['response']['status']['errors']
-          rescue => e
-            raise response.message
-          else
-            raise Animoto::Error.new(errors.collect { |e| e['message'] }.join(', '))
-          end
-        else
-          raise response.message
-        end
-      end
-    end
-    
-    # Parses a JSON response body into a Hash.
-    # @param [Net::HTTPResponse] response the response object
-    # @return [Hash] deserialized JSON response body
-    def parse_response response
-      JSON.parse(response.body)
+    rescue NoMethodError => e
+      raise Animoto::Error.new("Invalid response (#{error.inspect})")
     end
     
     # Creates the full content type string given a Resource class or instance
@@ -247,7 +241,7 @@ module Animoto
     #   "application/vnd.animoto.storyboard-v1+json")
     def content_type_of klass_or_instance
       klass = klass_or_instance.is_a?(Class) ? klass_or_instance : klass_or_instance.class
-      "#{BASE_CONTENT_TYPE}.#{klass.content_type}-v#{API_VERSION}+#{format}"
+      "#{BASE_CONTENT_TYPE}.#{klass.content_type}-v#{API_VERSION}+#{response_parser.format}"
     end
     
   end

data/lib/animoto/dynamic_class_loader.rb

@@ -0,0 +1,64 @@
+module Animoto
+  module DynamicClassLoader
+    
+    # If a reference is made to a class under this one that hasn't been initialized yet,
+    # this will attempt to require a file with that class' name (underscored). If one is
+    # found, and the file defines the class requested, will return that class object.
+    #
+    # @param [Symbol] const the uninitialized class' name
+    # @return [Class] the class found
+    # @raise [NameError] if the file defining the class isn't found, or if the file required
+    #   doesn't define the class.
+    def const_missing const
+      engine_name = underscore_class_name(const.to_s)
+      file_name = File.dirname(__FILE__) + "/#{search_path}/#{engine_name}.rb"
+      if File.exist?(file_name)
+        require file_name
+        const_defined?(const) ? const_get(const) : super
+      else
+        super
+      end
+    end
+            
+    # Returns the adapter class for the given symbol. If the file defining the class
+    # hasn't been loaded, will try to load it.
+    #
+    # @param [Symbol] engine the symbolic name of the adapter
+    # @return [Class] the class
+    # @raise [NameError] if the class isn't found
+    def [] engine
+      require(File.dirname(__FILE__) + "/#{search_path}/#{engine.to_s.gsub(/[^\w]/,'.?')}_adapter.rb") unless $".grep(/#{engine.to_s}_adapter/).first
+    rescue LoadError
+      raise NameError, "Couldn't locate adapter named \"#{engine}\""
+    else
+      adapter_map[engine]      
+    end
+
+    private
+
+    # Returns the path relative to this file where dynamically loaded files can be found.
+    # Defaults to the underscored class name plus 's'.
+    #
+    # @return [String] the path
+    def search_path
+      "#{underscore_class_name(self)}s"
+    end
+    
+    # Returns a Hash mapping the symbolic names for adapters to their classes.
+    #
+    # @return [Hash] the map of adapters
+    def adapter_map
+      @adapter_map ||= {}
+    end
+
+    # Turns a camel-cased class name into an underscored version. Will only affect the base name
+    # of the class, so, for example, Animoto::DirectingAndRenderingJob becomes 'directing_and_rendering_job'
+    #
+    # @param [Class, String] klass a class or name of a class
+    # @return [String] the underscored version of the name
+    def underscore_class_name klass
+      klass_name = klass.is_a?(Class) ? klass.name.split('::').last : klass
+      klass_name.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+    end
+  end
+end

data/lib/animoto/http_engine.rb

@@ -0,0 +1,34 @@
+module Animoto
+  class HTTPEngine
+    extend DynamicClassLoader
+    
+    # Make a request.
+    #
+    # @param [Symbol] method the HTTP method to use, should be lower-case (that is, :get
+    #   instead of :GET)
+    # @param [String] url the URL to request
+    # @param [String,nil] body the request body
+    # @param [Hash<String,String>] headers request headers to send; names will be sent as-is
+    #   (for example, use keys like "Content-Type" and not :content_type)
+    # @param [Hash<Symbol,Object>] options
+    #   @option options :timeout set a timeout
+    #   @option options :username the authentication username
+    #   @option options :password the authentication password
+    # @return [String] the response body
+    # @raise [NotImplementedError] if called on the abstract class
+    def request method, url, body = nil, headers = {}, options = {}
+      raise NotImplementedError
+    end
+    
+    private
+    
+    # Checks the response and raises an error if the status isn't success.
+    #
+    # @param [Fixnum] code the HTTP status code
+    # @param [String] body the HTTP response body
+    # @raise [Animoto::Error] if the status isn't between 200 and 299
+    def check_response code, body
+      throw(:fail, body) unless (200..299).include?(code)
+    end
+  end
+end

data/lib/animoto/http_engines/curl_adapter.rb

@@ -0,0 +1,39 @@
+require 'curl'
+
+module Animoto
+  class HTTPEngine
+    class CurlAdapter < Animoto::HTTPEngine
+      
+      def request method, url, body = nil, headers = {}, options = {}
+        curl = build_curl method, url, body, headers, options
+        perform curl, method
+        check_response curl.response_code, curl.body_str
+        curl.body_str
+      end
+      
+      private
+      
+      def build_curl method, url, body, headers, options
+        ::Curl::Easy.new(url) do |c|
+          c.username = options[:username]
+          c.password = options[:password]
+          c.timeout = options[:timeout]
+          c.post_body = body
+          headers.each { |header, value| c.headers[header] = value }
+        end
+      end
+      
+      def perform curl, method
+        case method
+        when :get
+          curl.http_get
+        when :post
+          curl.http_post(body)
+        end
+      end
+      
+    end
+    
+    adapter_map.merge! :curl => CurlAdapter
+  end
+end

data/lib/animoto/http_engines/net_http_adapter.rb

@@ -0,0 +1,55 @@
+require 'net/http'
+require 'net/https'
+
+module Animoto
+  class HTTPEngine
+    class NetHTTPAdapter < Animoto::HTTPEngine
+      
+      HTTP_METHOD_MAP   = {
+        :get  => Net::HTTP::Get,
+        :post => Net::HTTP::Post
+      }
+      
+      def request method, url, body = nil, headers = {}, options = {}
+        uri = URI.parse(url)
+        http = build_http uri
+        req = build_request method, uri, body, headers, options        
+        response = http.request req
+        check_response response.code.to_i, response.body
+        response.body
+      end
+      
+      private
+
+      # Makes a new HTTP object.
+      #
+      # @param [URI] uri a URI object of the request URL
+      # @return [Net::HTTP] the HTTP object
+      def build_http uri
+        http = Net::HTTP.new uri.host, uri.port
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        http
+      end
+      
+      # Builds the request object.
+      #
+      # @param [Symbol] method which HTTP method to use (should be lowercase, i.e. :get instead of :GET)
+      # @param [String] uri the request path
+      # @param [String, nil] body the request body
+      # @param [Hash<String,String>] headers the request headers (will be sent as-is, which means you should
+      #   specify "Content-Type" => "..." instead of, say, :content_type => "...")
+      # @param [Hash] options
+      # @return [Net::HTTPRequest] the request object
+      def build_request method, uri, body, headers, options
+        req = HTTP_METHOD_MAP[method].new uri.path
+        req.body = body
+        req.initialize_http_header headers
+        req.basic_auth options[:username], options[:password]
+        req
+      end      
+    end
+    
+    adapter_map.merge! :net_http => NetHTTPAdapter
+  end
+end

data/lib/animoto/http_engines/patron_adapter.rb

@@ -0,0 +1,27 @@
+require 'patron'
+
+module Animoto
+  class HTTPEngine
+    class PatronAdapter < Animoto::HTTPEngine
+      
+      def request method, url, body = nil, headers = {}, options = {}
+        session = build_session options
+        response = session.request method, url, headers, :data => body
+        check_response response.status, response.body
+        response.body
+      end
+      
+      private
+      
+      def build_session options
+        session = ::Patron::Session.new
+        session.timeout = options[:timeout]
+        session.username = options[:username]
+        session.password = options[:password]
+        session
+      end
+    end
+    
+    adapter_map.merge! :patron => PatronAdapter
+  end
+end

data/lib/animoto/http_engines/rest_client_adapter.rb

@@ -0,0 +1,25 @@
+require 'restclient'
+
+module Animoto
+  class HTTPEngine
+    class RestClientAdapter < Animoto::HTTPEngine
+      
+      def request method, url, body = nil, headers = {}, options = {}
+        response = ::RestClient::Request.execute({
+          :method => method,
+          :url => url,
+          :headers => headers,
+          :payload => body,
+          :user => options[:username],
+          :password => options[:password],
+          :timeout => options[:timeout]
+        })
+        check_response response.code, response.body
+        response.body
+      end
+      
+    end
+    
+    adapter_map.merge! :rest_client => RestClientAdapter
+  end
+end

data/lib/animoto/http_engines/typhoeus_adapter.rb

@@ -0,0 +1,24 @@
+require 'typhoeus'
+
+module Animoto
+  class HTTPEngine
+    class TyphoeusAdapter < Animoto::HTTPEngine
+      
+      def request method, url, body = nil, headers = {}, options = {}
+        response = ::Typhoeus::Request.run(url, {
+          :method => method,
+          :body => body,
+          :headers => headers,
+          :timeout => options[:timeout],
+          :username => options[:username],
+          :password => options[:password]
+        })
+        check_response response.code, response.body
+        response.body
+      end
+      
+    end
+    
+    adapter_map.merge! :typhoeus => TyphoeusAdapter
+  end
+end

data/lib/animoto/manifest.rb

@@ -10,12 +10,5 @@ module Animoto
       {}
     end
     
-    # Returns a representation of this manifest as JSON.
-    #
-    # @return [String] the manifest as JSON
-    def to_json
-      self.to_hash.to_json
-    end
-    
   end
 end

data/lib/animoto/resource.rb

@@ -50,13 +50,13 @@ module Animoto
       self.class.payload_key
     end
     
-    # Makes a new instance of this class from a deserialized JSON response body. Note that
+    # Makes a new instance of this class from a deserialized response body. Note that
     # it assumes the hash you're passing is structured correctly and does no format checking
     # at all, so if the hash is not in the "standard envelope", this method will most likely
     # raise an error.
     #
     # @private
-    # @param [Hash] body the deserialized JSON response body
+    # @param [Hash] body the deserialized response body
     # @return [Resource] an instance of this class
     def self.load body
       new unpack_standard_envelope(body)
@@ -116,7 +116,7 @@ module Animoto
     # Update this instance with new attributes from the response body.
     #
     # @private
-    # @param [Hash] body deserialized JSON from a response body
+    # @param [Hash] body deserialized from a response body
     # @return [self] this instance, updated
     def load body = {}
       instantiate unpack_standard_envelope(body)

data/lib/animoto/response_parser.rb

@@ -0,0 +1,38 @@
+module Animoto
+  class ResponseParser
+    extend DynamicClassLoader
+    
+    # Returns the format of this parser class.
+    # 
+    # @return [String] the format
+    def self.format
+      @format
+    end
+    
+    # Returns the format of this parser.
+    #
+    # @return [String] the format
+    def format
+      self.class.format
+    end
+    
+    # Parses a response body into a usable Hash.
+    #
+    # @param [String] body the HTTP response body
+    # @return [Hash] the parsed response
+    # @raise [NotImplementedError] if called on the abstract class
+    def parse body
+      raise NotImplementedError
+    end
+    
+    # Serializes a Hash into the format for this parser.
+    #
+    # @param [Hash] hash the hash to serialize
+    # @return [String] the serialized data
+    # @raise [NotImplementedError] if called on the abstract class
+    def unparse hash
+      raise NotImplementedError
+    end
+
+  end
+end

data/lib/animoto/response_parsers/json_adapter.rb

@@ -0,0 +1,21 @@
+require 'json'
+
+module Animoto
+  class ResponseParser
+    class JSONAdapter < Animoto::ResponseParser
+      
+      @format = 'json'
+      
+      def parse body
+        ::JSON.parse body
+      end
+      
+      def unparse hash
+        ::JSON.unparse hash
+      end
+      
+    end
+    
+    adapter_map.merge! :json => JSONAdapter
+  end
+end

data/lib/animoto/response_parsers/yajl_adapter.rb

@@ -0,0 +1,21 @@
+require 'yajl'
+
+module Animoto
+  class ResponseParser
+    class YajlAdapter < Animoto::ResponseParser
+      
+      @format = 'json'
+      
+      def parse body
+        ::Yajl::Parser.parse body
+      end
+      
+      def unparse hash
+        ::Yajl::Encoder.encode hash
+      end
+      
+    end
+    
+    adapter_map.merge! :yajl => YajlAdapter
+  end
+end

data/lib/animoto/standard_envelope.rb

@@ -20,7 +20,7 @@ module Animoto
         {
           :url => body['response']['payload'][payload_key]['links']['self'],
           :errors => body['response']['status']['errors'] || []
-        }  
+        }
       end
     end
   end

data/lib/animoto.rb

@@ -1,5 +1,5 @@
 module Animoto
   def self.version
-    "0.0.0.alpha3"
+    "0.0.0.alpha4"
   end
 end

data/spec/animoto/client_spec.rb

@@ -1,3 +1,4 @@
+require 'base64'
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe Animoto::Client do
@@ -42,15 +43,16 @@ describe Animoto::Client do
     
     describe "automatically" do
       before do
+        @here_path  = File.expand_path("./.animotorc")
         @home_path  = File.expand_path("~/.animotorc")
         @etc_path   = "/etc/.animotorc"
         @config     = "key: joe\nsecret: secret\nendpoint: https://api.animoto.com/"
       end
       
-      describe "when ~/.animotorc exists" do
+      describe "when ./.animotorc exists" do
         before do
-          File.stubs(:exist?).with(@home_path).returns(true)
-          File.stubs(:read).with(@home_path).returns(@config)
+          File.stubs(:exist?).with(@here_path).returns(true)
+          File.stubs(:read).with(@here_path).returns(@config)
         end
         
         it "should configure itself based on the options in ~/.animotorc" do
@@ -61,28 +63,47 @@ describe Animoto::Client do
         end
       end
       
-      describe "when ~/.animotorc doesn't exist" do
+      describe "when ./.animotorc doesn't exist" do
         before do
-          File.stubs(:exist?).with(@home_path).returns(false)
+          File.stubs(:exist?).with(@here_path).returns(false)
         end
         
-        describe "when /etc/.animotorc exists" do
+        describe "when ~/.animotorc exists" do
           before do
-            File.stubs(:exist?).with(@etc_path).returns(true)
-            File.stubs(:read).with(@etc_path).returns(@config)
+            File.stubs(:exist?).with(@home_path).returns(true)
+            File.stubs(:read).with(@home_path).returns(@config)
           end
-          
-          it "should configure itself based on the options in /etc/.animotorc" do
+        
+          it "should configure itself based on the options in ~/.animotorc" do
             c = Animoto::Client.new
             c.key.should == "joe"
             c.secret.should == "secret"
             c.endpoint.should == "https://api.animoto.com/"
           end
         end
+      
+        describe "when ~/.animotorc doesn't exist" do
+          before do
+            File.stubs(:exist?).with(@home_path).returns(false)
+          end
+        
+          describe "when /etc/.animotorc exists" do
+            before do
+              File.stubs(:exist?).with(@etc_path).returns(true)
+              File.stubs(:read).with(@etc_path).returns(@config)
+            end
+          
+            it "should configure itself based on the options in /etc/.animotorc" do
+              c = Animoto::Client.new
+              c.key.should == "joe"
+              c.secret.should == "secret"
+            end
+          end
         
-        describe "when /etc/.animotorc doesn't exist" do
-          it "should raise an error" do
-            lambda { Animoto::Client.new }.should raise_error
+          describe "when /etc/.animotorc doesn't exist" do
+            it "should raise an error" do
+              lambda { Animoto::Client.new }.should raise_error
+            end
           end
         end
       end
@@ -91,9 +112,10 @@ describe Animoto::Client do
     
   describe "finding an instance by identifier" do
     before do
-      @url = "https://api.animoto.com/storyboards/1"
-      @body = {'response'=>{'status'=>{'code'=>200}},'payload'=>{'storyboard'=>{'links'=>{'self'=>@url}}}}
-      stub_request(:get, @url).to_return(:body => @body.to_json, :status => [200,"OK"])
+      @url = "https://joe:secret@api.animoto.com/storyboards/1"
+      hash = {'response'=>{'status'=>{'code'=>200},'payload'=>{'storyboard'=>{'links'=>{'self'=>@url,'preview'=>'http://animoto.com/preview/1.mp4'},'metadata'=>{'duration'=>100,'visuals_count'=>1}}}}}
+      body = client.response_parser.unparse(hash)
+      stub_request(:get, @url).to_return(:body => body, :status => [200,"OK"])
     end
     
     it "should make a GET request to the given url" do
@@ -103,7 +125,7 @@ describe Animoto::Client do
     
     it "should ask for a response in the proper format" do
       client.find(Animoto::Storyboard, @url)
-      WebMock.should have_requested(:get, @url).with(:headers => { 'Accept' => "application/vnd.animoto.storyboard-v1+json"})
+      WebMock.should have_requested(:get, @url).with(:headers => { 'Accept' => "application/vnd.animoto.storyboard-v1+json" })
     end
     
     it "should not sent a request body" do
@@ -118,10 +140,11 @@ describe Animoto::Client do
   
   describe "reloading an instance" do
     before do
-      @url = 'https://api.animoto.com/jobs/directing/1'
+      @url = 'https://joe:secret@api.animoto.com/jobs/directing/1'
       @job = Animoto::DirectingJob.new :state => 'initial', :url => @url
-      @body = {'response'=>{'status'=>{'code'=>200}},'payload'=>{'directing_job'=>{'state'=>'retrieving_assets','links'=>{'self'=>@url}}}}
-      stub_request(:get, @url).to_return(:body => @body.to_json, :status => [200,"OK"])
+      hash = {'response'=>{'status'=>{'code'=>200},'payload'=>{'directing_job'=>{'state'=>'retrieving_assets','links'=>{'self'=>@url,'storyboard'=>'http://api.animoto.com/storyboards/1'}}}}}
+      body = client.response_parser.unparse(hash)
+      stub_request(:get, @url).to_return(:body => body, :status => [200,"OK"])
       @job.state.should == 'initial' # sanity check
     end
     

data/spec/animoto/http_engine_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Animoto::HTTPEngine do
+  
+  describe "autoloading subclasses" do
+    before do
+      Animoto::HTTPEngine.const_defined?(:BeefHearts).should be_false
+    end
+    
+    
+    
+    after do
+      Animoto::HTTPEngine.remove_const(:BeefHearts)
+    end
+  end
+  
+  describe "making a request" do
+    before do
+      @engine = Animoto::HTTPEngine.new
+    end
+    
+    it "should raise an implementation error" do
+      lambda { @engine.request(:get, "http://www.example.com/thing") }.should raise_error(NotImplementedError)
+    end
+  end
+  
+end

data/spec/animoto/response_parsers/json_adapter_spec.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Animoto::ResponseParser::JSONAdapter do
+  
+  before do
+    @parser = Animoto::ResponseParser::JSONAdapter.new
+  end
+  
+  it "should be JSON format" do
+    @parser.format.should == 'json'
+  end
+  
+  describe "parsing" do
+    before do
+      @json = %Q!{"result":{"rank":1,"score":1.9,"tags":["hooray","for","dolphins"],"message":"woohoo"}}!
+      @hash = @parser.parse(@json)
+    end
+    
+    it "should return a hash" do
+      @hash.should be_an_instance_of(Hash)
+    end
+    
+    it "should turn the object root into a hash" do
+      @hash.should have_key('result')
+    end
+    
+    it "should turn array elements into an array" do
+      @hash['result'].should have_key('tags')
+      @hash['result']['tags'].should be_an_instance_of(Array)
+    end
+    
+    it "should preserve the order of elements in an array" do
+      @hash['result']['tags'].should == ["hooray", "for", "dolphins"]
+    end
+    
+    it "should turn each object attribute into a key/value pair in the hash" do
+      @hash['result'].should have_key('rank')
+      @hash['result']['rank'].should be_an_instance_of(Fixnum)
+    end
+    
+    it "should turn attributes with strictly numeric values into integers" do
+      @hash['result']['rank'].should eql(1)
+    end
+    
+    it "should turn attributes with content representing floats into floats" do
+      @hash['result']['score'].should eql(1.9)
+    end
+    
+    it "should turn strings into strings" do
+      @hash['result']['message'].should be_an_instance_of(String)
+      @hash['result']['message'].should == "woohoo"
+    end
+  end
+  
+  describe "unparsing" do
+    before do
+      @obj = {
+        'result' => {
+          'tags'    => [ 'hooray', 'for', 'dolphins' ],
+          'message' => 'woohoo',
+          'rank'    => 1,
+          'score'   => 1.9
+        }
+      }
+      @json_str = @parser.unparse(@obj)
+      @json = ::JSON.parse(@json_str)
+    end
+    
+    it "should turn hashes into objects with attributes" do
+      @json.should have_key('result')
+      @json['result'].should_not be_empty
+    end
+    
+    it "should turn arrays into arrays" do
+      @json['result'].should have_key('tags')
+      @json['result']['tags'].should be_an_instance_of(Array)
+    end
+    
+    it "should turn strings into text content" do
+      @json['result'].should have_key('message')
+      @json['result']['message'].should == "woohoo"
+    end
+    
+    it "should turn integers into integers" do
+      @json_str.should =~ /"rank"\s*:\s*1/
+    end
+    
+    it "should turn floats into floats" do
+      @json_str.should =~ /"score"\s*:\s*1\.9/
+    end
+  end
+  
+end

data/spec/animoto/response_parsers/yajl_adapter_spec.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Animoto::ResponseParser::YajlAdapter do
+  
+  before do
+    @parser = Animoto::ResponseParser::YajlAdapter.new
+  end
+  
+  it "should be JSON format" do
+    @parser.format.should == 'json'
+  end
+  
+  describe "parsing" do
+    before do
+      @json = %Q!{"result":{"rank":1,"score":1.9,"tags":["hooray","for","dolphins"],"message":"woohoo"}}!
+      @hash = @parser.parse(@json)
+    end
+    
+    it "should return a hash" do
+      @hash.should be_an_instance_of(Hash)
+    end
+    
+    it "should turn the object root into a hash" do
+      @hash.should have_key('result')
+    end
+    
+    it "should turn array elements into an array" do
+      @hash['result'].should have_key('tags')
+      @hash['result']['tags'].should be_an_instance_of(Array)
+    end
+    
+    it "should preserve the order of elements in an array" do
+      @hash['result']['tags'].should == ["hooray", "for", "dolphins"]
+    end
+    
+    it "should turn each object attribute into a key/value pair in the hash" do
+      @hash['result'].should have_key('rank')
+      @hash['result']['rank'].should be_an_instance_of(Fixnum)
+    end
+    
+    it "should turn attributes with strictly numeric values into integers" do
+      @hash['result']['rank'].should eql(1)
+    end
+    
+    it "should turn attributes with content representing floats into floats" do
+      @hash['result']['score'].should eql(1.9)
+    end
+    
+    it "should turn strings into strings" do
+      @hash['result']['message'].should be_an_instance_of(String)
+      @hash['result']['message'].should == "woohoo"
+    end
+  end
+  
+  describe "unparsing" do
+    before do
+      @obj = {
+        'result' => {
+          'tags'    => [ 'hooray', 'for', 'dolphins' ],
+          'message' => 'woohoo',
+          'rank'    => 1,
+          'score'   => 1.9
+        }
+      }
+      @json_str = @parser.unparse(@obj)
+      @json = ::JSON.parse(@json_str)
+    end
+    
+    it "should turn hashes into objects with attributes" do
+      @json.should have_key('result')
+      @json['result'].should_not be_empty
+    end
+    
+    it "should turn arrays into arrays" do
+      @json['result'].should have_key('tags')
+      @json['result']['tags'].should be_an_instance_of(Array)
+    end
+    
+    it "should turn strings into text content" do
+      @json['result'].should have_key('message')
+      @json['result']['message'].should == "woohoo"
+    end
+    
+    it "should turn integers into integers" do
+      @json_str.should =~ /"rank"\s*:\s*1/
+    end
+    
+    it "should turn floats into floats" do
+      @json_str.should =~ /"score"\s*:\s*1\.9/
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -7,4 +7,4 @@ Spec::Runner.configure do |config|
   config.include WebMock
 end
 
-require File.dirname(__FILE__) + '/../lib/animoto/client'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/animoto/client')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: animoto
 version: !ruby/object:Gem::Version 
-  hash: -1710980559
+  hash: -1710980402
   prerelease: true
   segments: 
   - 0
   - 0
   - 0
-  - alpha3
-  version: 0.0.0.alpha3
+  - alpha4
+  version: 0.0.0.alpha4
 platform: ruby
 authors: 
 - Animoto
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-07 00:00:00 -04:00
+date: 2010-09-08 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -53,14 +53,24 @@ files:
 - ./lib/animoto/directing_and_rendering_manifest.rb
 - ./lib/animoto/directing_job.rb
 - ./lib/animoto/directing_manifest.rb
+- ./lib/animoto/dynamic_class_loader.rb
 - ./lib/animoto/errors.rb
 - ./lib/animoto/footage.rb
+- ./lib/animoto/http_engine.rb
+- ./lib/animoto/http_engines/curl_adapter.rb
+- ./lib/animoto/http_engines/net_http_adapter.rb
+- ./lib/animoto/http_engines/patron_adapter.rb
+- ./lib/animoto/http_engines/rest_client_adapter.rb
+- ./lib/animoto/http_engines/typhoeus_adapter.rb
 - ./lib/animoto/image.rb
 - ./lib/animoto/job.rb
 - ./lib/animoto/manifest.rb
 - ./lib/animoto/rendering_job.rb
 - ./lib/animoto/rendering_manifest.rb
 - ./lib/animoto/resource.rb
+- ./lib/animoto/response_parser.rb
+- ./lib/animoto/response_parsers/json_adapter.rb
+- ./lib/animoto/response_parsers/yajl_adapter.rb
 - ./lib/animoto/song.rb
 - ./lib/animoto/standard_envelope.rb
 - ./lib/animoto/storyboard.rb
@@ -76,11 +86,14 @@ files:
 - ./spec/animoto/directing_job_spec.rb
 - ./spec/animoto/directing_manifest_spec.rb
 - ./spec/animoto/footage_spec.rb
+- ./spec/animoto/http_engine_spec.rb
 - ./spec/animoto/image_spec.rb
 - ./spec/animoto/job_spec.rb
 - ./spec/animoto/rendering_job_spec.rb
 - ./spec/animoto/rendering_manifest_spec.rb
 - ./spec/animoto/resource_spec.rb
+- ./spec/animoto/response_parsers/json_adapter_spec.rb
+- ./spec/animoto/response_parsers/yajl_adapter_spec.rb
 - ./spec/animoto/song_spec.rb
 - ./spec/animoto/standard_envelope_spec.rb
 - ./spec/animoto/storyboard_spec.rb