koala 1.1.0 → 1.2.0

data/lib/koala/http_service.rb

@@ -0,0 +1,176 @@
+require 'faraday'
+
+module Koala
+  class Response
+    attr_reader :status, :body, :headers
+    def initialize(status, body, headers)
+      @status = status
+      @body = body
+      @headers = headers
+    end
+  end
+
+  module HTTPService
+    # common functionality for all HTTP services
+
+    class << self
+      attr_accessor :faraday_middleware, :http_options
+    end
+
+    @http_options ||= {}
+    
+    DEFAULT_MIDDLEWARE = Proc.new do |builder|
+      builder.request :multipart
+      builder.request :url_encoded
+      builder.adapter Faraday.default_adapter
+    end
+
+    def self.server(options = {})
+      server = "#{options[:rest_api] ? Facebook::REST_SERVER : Facebook::GRAPH_SERVER}"
+      server.gsub!(/\.facebook/, "-video.facebook") if options[:video]
+      "#{options[:use_ssl] ? "https" : "http"}://#{options[:beta] ? "beta." : ""}#{server}"
+    end
+
+    def self.make_request(path, args, verb, options = {})
+      # if the verb isn't get or post, send it as a post argument
+      args.merge!({:method => verb}) && verb = "post" if verb != "get" && verb != "post"
+
+      # turn all the keys to strings (Faraday has issues with symbols under 1.8.7) and resolve UploadableIOs
+      params = args.inject({}) {|hash, kv| hash[kv.first.to_s] = kv.last.is_a?(UploadableIO) ? kv.last.to_upload_io : kv.last; hash}
+
+      # figure out our options for this request   
+      request_options = {:params => (verb == "get" ? params : {})}.merge(http_options || {}).merge(process_options(options))
+      request_options[:use_ssl] = true if args["access_token"] # require http if there's a token
+
+      # set up our Faraday connection
+      # we have to manually assign params to the URL or the
+      conn = Faraday.new(server(request_options), request_options, &(faraday_middleware || DEFAULT_MIDDLEWARE))
+
+      response = conn.send(verb, path, (verb == "post" ? params : {}))
+      Koala::Response.new(response.status.to_i, response.body, response.headers)
+    end
+
+    def self.encode_params(param_hash)
+      # unfortunately, we can't use to_query because that's Rails, not Ruby
+      # if no hash (e.g. no auth token) return empty string
+      # this is used mainly by the Batch API nowadays
+      ((param_hash || {}).collect do |key_and_value|
+        key_and_value[1] = MultiJson.encode(key_and_value[1]) unless key_and_value[1].is_a? String
+        "#{key_and_value[0].to_s}=#{CGI.escape key_and_value[1]}"
+      end).join("&")
+    end
+    
+    # deprecations
+    # not elegant or compact code, but temporary
+    
+    def self.always_use_ssl
+      Koala::Utils.deprecate("HTTPService.always_use_ssl is now HTTPService.http_options[:use_ssl]; always_use_ssl will be removed in a future version.")
+      http_options[:use_ssl]
+    end
+
+    def self.always_use_ssl=(value)
+      Koala::Utils.deprecate("HTTPService.always_use_ssl is now HTTPService.http_options[:use_ssl]; always_use_ssl will be removed in a future version.")
+      http_options[:use_ssl] = value
+    end
+    
+    def self.timeout
+      Koala::Utils.deprecate("HTTPService.timeout is now HTTPService.http_options[:timeout]; .timeout will be removed in a future version.")
+      http_options[:timeout]
+    end
+
+    def self.timeout=(value)
+      Koala::Utils.deprecate("HTTPService.timeout is now HTTPService.http_options[:timeout]; .timeout will be removed in a future version.")
+      http_options[:timeout] = value
+    end
+    
+    def self.timeout
+      Koala::Utils.deprecate("HTTPService.timeout is now HTTPService.http_options[:timeout]; .timeout will be removed in a future version.")
+      http_options[:timeout]
+    end
+
+    def self.timeout=(value)
+      Koala::Utils.deprecate("HTTPService.timeout is now HTTPService.http_options[:timeout]; .timeout will be removed in a future version.")
+      http_options[:timeout] = value
+    end
+    
+    def self.proxy
+      Koala::Utils.deprecate("HTTPService.proxy is now HTTPService.http_options[:proxy]; .proxy will be removed in a future version.")
+      http_options[:proxy]
+    end
+
+    def self.proxy=(value)
+      Koala::Utils.deprecate("HTTPService.proxy is now HTTPService.http_options[:proxy]; .proxy will be removed in a future version.")
+      http_options[:proxy] = value
+    end
+    
+    def self.ca_path
+      Koala::Utils.deprecate("HTTPService.ca_path is now (HTTPService.http_options[:ssl] ||= {})[:ca_path]; .ca_path will be removed in a future version.")
+      (http_options[:ssl] || {})[:ca_path]
+    end
+
+    def self.ca_path=(value)
+      Koala::Utils.deprecate("HTTPService.ca_path is now (HTTPService.http_options[:ssl] ||= {})[:ca_path]; .ca_path will be removed in a future version.")
+      (http_options[:ssl] ||= {})[:ca_path] = value
+    end
+    
+    def self.ca_file
+      Koala::Utils.deprecate("HTTPService.ca_file is now (HTTPService.http_options[:ssl] ||= {})[:ca_file]; .ca_file will be removed in a future version.")
+      (http_options[:ssl] || {})[:ca_file]
+    end
+
+    def self.ca_file=(value)
+      Koala::Utils.deprecate("HTTPService.ca_file is now (HTTPService.http_options[:ssl] ||= {})[:ca_file]; .ca_file will be removed in a future version.")
+      (http_options[:ssl] ||= {})[:ca_file] = value
+    end
+
+    def self.verify_mode
+      Koala::Utils.deprecate("HTTPService.verify_mode is now (HTTPService.http_options[:ssl] ||= {})[:verify_mode]; .verify_mode will be removed in a future version.")
+      (http_options[:ssl] || {})[:verify_mode]
+    end
+
+    def self.verify_mode=(value)
+      Koala::Utils.deprecate("HTTPService.verify_mode is now (HTTPService.http_options[:ssl] ||= {})[:verify_mode]; .verify_mode will be removed in a future version.")
+      (http_options[:ssl] ||= {})[:verify_mode] = value
+    end
+
+    def self.process_options(options)
+      if typhoeus_options = options.delete(:typhoeus_options)
+        Koala::Utils.deprecate("typhoeus_options should now be included directly in the http_options hash.  Support for this key will be removed in a future version.")
+        options = options.merge(typhoeus_options)
+      end
+      
+      if ca_file = options.delete(:ca_file)
+        Koala::Utils.deprecate("http_options[:ca_file] should now be passed inside (http_options[:ssl] = {}) -- that is, http_options[:ssl][:ca_file].  Support for this key will be removed in a future version.")
+        (options[:ssl] ||= {})[:ca_file] = ca_file
+      end
+
+      if ca_path = options.delete(:ca_path)
+        Koala::Utils.deprecate("http_options[:ca_path] should now be passed inside (http_options[:ssl] = {}) -- that is, http_options[:ssl][:ca_path].  Support for this key will be removed in a future version.")
+        (options[:ssl] ||= {})[:ca_path] = ca_path
+      end
+
+      if verify_mode = options.delete(:verify_mode)
+        Koala::Utils.deprecate("http_options[:verify_mode] should now be passed inside (http_options[:ssl] = {}) -- that is, http_options[:ssl][:verify_mode].  Support for this key will be removed in a future version.")
+        (options[:ssl] ||= {})[:verify_mode] = verify_mode
+      end
+      
+      options
+    end   
+  end
+  
+  module TyphoeusService
+    def self.deprecated_interface
+      # support old-style interface with a warning
+      Koala::Utils.deprecate("the TyphoeusService module is deprecated; to use Typhoeus, set Faraday.default_adapter = :typhoeus.  Enabling Typhoeus for all Faraday connections.")
+      Faraday.default_adapter = :typhoeus
+    end
+  end
+
+  module NetHTTPService
+    def self.deprecated_interface
+      # support old-style interface with a warning
+      Koala::Utils.deprecate("the NetHTTPService module is deprecated; to use Net::HTTP, set Faraday.default_adapter = :net_http.  Enabling Net::HTTP for all Faraday connections.")
+      Faraday.default_adapter = :net_http
+    end
+  end
+end

data/lib/koala/oauth.rb

@@ -9,31 +9,18 @@ module Koala
       end
 
       def get_user_info_from_cookie(cookie_hash)
-        # Parses the cookie set by the official Facebook JavaScript SDK.
-        #
-        # cookies should be a Hash, like the one Rails provides
+        # Parses the cookie set Facebook's JavaScript SDK.
+        # You can pass Rack/Rails/Sinatra's cookie hash directly to this method.
         #
         # If the user is logged in via Facebook, we return a dictionary with the
         # keys "uid" and "access_token". The former is the user's Facebook ID,
         # and the latter can be used to make authenticated requests to the Graph API.
         # If the user is not logged in, we return None.
-        #
-        # Download the official Facebook JavaScript SDK at
-        # http://github.com/facebook/connect-js/. Read more about Facebook
-        # authentication at http://developers.facebook.com/docs/authentication/.
-
-        if fb_cookie = cookie_hash["fbs_" + @app_id.to_s]
-          # remove the opening/closing quote
-          fb_cookie = fb_cookie.gsub(/\"/, "")
-
-          # since we no longer get individual cookies, we have to separate out the components ourselves
-          components = {}
-          fb_cookie.split("&").map {|param| param = param.split("="); components[param[0]] = param[1]}
-
-          # generate the signature and make sure it matches what we expect
-          auth_string = components.keys.sort.collect {|a| a == "sig" ? nil : "#{a}=#{components[a]}"}.reject {|a| a.nil?}.join("")
-          sig = Digest::MD5.hexdigest(auth_string + @app_secret)
-          sig == components["sig"] && (components["expires"] == "0" || Time.now.to_i < components["expires"].to_i) ? components : nil
+
+        if signed_cookie = cookie_hash["fbsr_#{@app_id}"]
+          parse_signed_cookie(signed_cookie)
+        elsif unsigned_cookie = cookie_hash["fbs_#{@app_id}"]
+          parse_unsigned_cookie(unsigned_cookie)
         end
       end
       alias_method :get_user_info_from_cookies, :get_user_info_from_cookie
@@ -52,7 +39,7 @@ module Koala
         permissions = options[:permissions]
         scope = permissions ? "&scope=#{permissions.is_a?(Array) ? permissions.join(",") : permissions}" : ""
         display = options.has_key?(:display) ? "&display=#{options[:display]}" : ""
-        
+
         callback = options[:callback] || @oauth_callback_url
         raise ArgumentError, "url_for_oauth_code must get a callback either from the OAuth object or in the options!" unless callback
 
@@ -70,7 +57,7 @@ module Koala
       def get_access_token_info(code, options = {})
         # convenience method to get a parsed token from Facebook for a given code
         # should this require an OAuth callback URL?
-        get_token_from_server({:code => code, :redirect_uri => @oauth_callback_url}, false, options)
+        get_token_from_server({:code => code, :redirect_uri => options[:redirect_uri] || @oauth_callback_url}, false, options)
       end
 
       def get_access_token(code, options = {})
@@ -104,7 +91,7 @@ module Koala
         raise "SignedRequest: Unsupported algorithm #{envelope['algorithm']}" if envelope['algorithm'] != 'HMAC-SHA256'
 
         # now see if the signature is valid (digest, key, data)
-        hmac = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, @app_secret, encoded_envelope.tr("-_", "+/"))
+        hmac = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, @app_secret, encoded_envelope)
         raise 'SignedRequest: Invalid signature' if (signature != hmac)
 
         return envelope
@@ -162,6 +149,29 @@ module Koala
         end
         components
       end
+      
+      def parse_unsigned_cookie(fb_cookie)
+        # remove the opening/closing quote
+        fb_cookie = fb_cookie.gsub(/\"/, "")
+
+        # since we no longer get individual cookies, we have to separate out the components ourselves
+        components = {}
+        fb_cookie.split("&").map {|param| param = param.split("="); components[param[0]] = param[1]}
+
+        # generate the signature and make sure it matches what we expect
+        auth_string = components.keys.sort.collect {|a| a == "sig" ? nil : "#{a}=#{components[a]}"}.reject {|a| a.nil?}.join("")
+        sig = Digest::MD5.hexdigest(auth_string + @app_secret)
+        sig == components["sig"] && (components["expires"] == "0" || Time.now.to_i < components["expires"].to_i) ? components : nil
+      end
+      
+      def parse_signed_cookie(fb_cookie)
+        components = parse_signed_request(fb_cookie)
+        if (code = components["code"]) && token_info = get_access_token_info(code, :redirect_uri => '')
+          components.merge(token_info)
+        else
+          nil
+        end
+      end
 
       def fetch_token_string(args, post = false, endpoint = "access_token", options = {})
         Koala.make_request("/oauth/#{endpoint}", {
@@ -178,4 +188,4 @@ module Koala
       end
     end
   end
-end
+end

data/lib/koala/realtime_updates.rb

@@ -1,15 +1,13 @@
-require 'koala'
-
 module Koala
   module Facebook
     module RealtimeUpdateMethods
       # note: to subscribe to real-time updates, you must have an application access token
-      
+
       def self.included(base)
         # make the attributes readable
         base.class_eval do
-          attr_reader :app_id, :app_access_token, :secret
-          
+          attr_reader :api, :app_id, :app_access_token, :secret
+
           # parses the challenge params and makes sure the call is legitimate
           # returns the challenge string to be sent back to facebook if true
           # returns false otherwise
@@ -20,7 +18,7 @@ module Koala
                 # you can make sure this is legitimate through two ways
                 # if your store the token across the calls, you can pass in the token value
                 # and we'll make sure it matches
-                (verify_token && params["hub.verify_token"] == verify_token) ||        
+                (verify_token && params["hub.verify_token"] == verify_token) ||
                 # alternately, if you sent a specially-constructed value (such as a hash of various secret values)
                 # you can pass in a block, which we'll call with the verify_token sent by Facebook
                 # if it's legit, return anything that evaluates to true; otherwise, return nil or false
@@ -32,7 +30,7 @@ module Koala
           end
         end
       end
-      
+
       def initialize(options = {})
         @app_id = options[:app_id]
         @app_access_token = options[:app_access_token]
@@ -40,22 +38,22 @@ module Koala
         unless @app_id && (@app_access_token || @secret) # make sure we have what we need
           raise ArgumentError, "Initialize must receive a hash with :app_id and either :app_access_token or :secret! (received #{options.inspect})"
         end
-        
+
         # fetch the access token if we're provided a secret
         if @secret && !@app_access_token
           oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
           @app_access_token = oauth.get_app_access_token
         end
-        
-        @graph_api = GraphAPI.new(@app_access_token)
+
+        @graph_api = API.new(@app_access_token)
       end
-      
+
       # subscribes for realtime updates
       # your callback_url must be set up to handle the verification request or the subscription will not be set up
       # http://developers.facebook.com/docs/api/realtime
       def subscribe(object, fields, callback_url, verify_token)
         args = {
-          :object => object, 
+          :object => object,
           :fields => fields,
           :callback_url => callback_url,
           :verify_token => verify_token
@@ -63,7 +61,7 @@ module Koala
         # a subscription is a success if Facebook returns a 200 (after hitting your server for verification)
         @graph_api.graph_call(subscription_path, args, 'post', :http_component => :status) == 200
       end
-          
+
       # removes subscription for object
       # if object is nil, it will remove all subscriptions
       def unsubscribe(object = nil)
@@ -71,16 +69,21 @@ module Koala
         args[:object] = object if object
         @graph_api.graph_call(subscription_path, args, 'delete', :http_component => :status) == 200
       end
-  
+
       def list_subscriptions
-        @graph_api.graph_call(subscription_path)["data"]
+        @graph_api.graph_call(subscription_path)
+      end
+
+      def graph_api
+        Koala::Utils.deprecate("the TestUsers.graph_api accessor is deprecated and will be removed in a future version; please use .api instead.")
+        @api
       end
-      
+
       protected
-      
+
       def subscription_path
         @subscription_path ||= "#{@app_id}/subscriptions"
       end
     end
   end
-end
+end

data/lib/koala/rest_api.rb

@@ -4,7 +4,7 @@ module Koala
 
     module RestAPIMethods
       def fql_query(fql, args = {}, options = {})
-        rest_call('fql.query', args.merge(:query => fql), options) 
+        rest_call('fql.query', args.merge(:query => fql), options)
       end
 
       def fql_multiquery(queries = {}, args = {}, options = {})

data/lib/koala/test_users.rb

@@ -3,7 +3,14 @@ require 'koala'
 module Koala
   module Facebook
     module TestUserMethods
-      
+
+      def self.included(base)
+        base.class_eval do
+          # make the Graph API accessible in case someone wants to make other calls to interact with their users
+          attr_reader :api, :app_id, :app_access_token, :secret
+        end
+      end
+
       def initialize(options = {})
         @app_id = options[:app_id]
         @app_access_token = options[:app_access_token]
@@ -17,29 +24,34 @@ module Koala
           oauth = Koala::Facebook::OAuth.new(@app_id, @secret)
           @app_access_token = oauth.get_app_access_token
         end
-        @graph_api = GraphAPI.new(@app_access_token)
+        @api = API.new(@app_access_token)
       end
 
       def create(installed, permissions = nil, args = {}, options = {})
         # Creates and returns a test user
         args['installed'] = installed
         args['permissions'] = (permissions.is_a?(Array) ? permissions.join(",") : permissions) if installed
-        result = @graph_api.graph_call(accounts_path, args, "post", options)
+        result = @api.graph_call(accounts_path, args, "post", options)
       end
-      
+
       def list
-        @graph_api.graph_call(accounts_path)["data"]
+        @api.graph_call(accounts_path)
       end
-      
+
       def delete(test_user)
         test_user = test_user["id"] if test_user.is_a?(Hash)
-        @graph_api.delete_object(test_user)
+        @api.delete_object(test_user)
       end
-      
+
       def delete_all
-        list.each {|u| delete u }
+        list.each {|u| delete u}
+      end
+
+      def update(test_user, args = {}, http_options = {})
+        test_user = test_user["id"] if test_user.is_a?(Hash)
+        @api.graph_call(test_user, args, "post", http_options)
       end
-      
+
       def befriend(user1_hash, user2_hash)
         user1_id = user1_hash["id"] || user1_hash[:id]
         user2_id = user2_hash["id"] || user2_hash[:id]
@@ -51,16 +63,15 @@ module Koala
           # but the Facebook call would fail
           raise ArgumentError, "TestUsers#befriend requires hash arguments for both users with id and access_token"
         end
-        
-        u1_graph_api = GraphAPI.new(user1_token)
-        u2_graph_api = GraphAPI.new(user2_token)
 
-        u1_graph_api.graph_call("#{user1_id}/friends/#{user2_id}", {}, "post") && 
+        u1_graph_api = API.new(user1_token)
+        u2_graph_api = API.new(user2_token)
+
+        u1_graph_api.graph_call("#{user1_id}/friends/#{user2_id}", {}, "post") &&
           u2_graph_api.graph_call("#{user2_id}/friends/#{user1_id}", {}, "post")
       end
 
       def create_network(network_size, installed = true, permissions = '')
-        network_size = 50 if network_size > 50 # FB's max is 50
         users = (0...network_size).collect { create(installed, permissions) }
         friends = users.clone
         users.each do |user|
@@ -73,9 +84,14 @@ module Koala
         end
         return users
       end
-      
+
+      def graph_api
+        Koala::Utils.deprecate("the TestUsers.graph_api accessor is deprecated and will be removed in a future version; please use .api instead.")
+        @api
+      end
+
       protected
-      
+
       def accounts_path
         @accounts_path ||= "/#{@app_id}/accounts/test-users"
       end

data/lib/koala/uploadable_io.rb

@@ -1,36 +1,30 @@
-require 'koala'
+require "net/http/post/multipart"
 
 module Koala
   class UploadableIO
-    attr_reader :io_or_path, :content_type, :requires_base_http_service
+    attr_reader :io_or_path, :content_type, :filename
 
     def initialize(io_or_path_or_mixed, content_type = nil, filename = nil)
       # see if we got the right inputs
-      if content_type.nil?
-        parse_init_mixed_param io_or_path_or_mixed
-      elsif !content_type.nil? && (io_or_path_or_mixed.respond_to?(:read) or io_or_path_or_mixed.kind_of?(String))
-        @io_or_path = io_or_path_or_mixed
-        @content_type = content_type
-      end
-      
-      # Probably a StringIO or similar object, which won't work with Typhoeus
-      @requires_base_http_service = @io_or_path.respond_to?(:read) && !@io_or_path.kind_of?(File)
+      parse_init_mixed_param io_or_path_or_mixed, content_type
 
       # filename is used in the Ads API
-      @filename = filename || "koala-io-file.dum"
+      # if it's provided, take precedence over the detected filename
+      # otherwise, fall back to a dummy name
+      @filename = filename || @filename || "koala-io-file.dum"
 
       raise KoalaError.new("Invalid arguments to initialize an UploadableIO") unless @io_or_path
-      raise KoalaError.new("Unable to determine MIME type for UploadableIO") if !@content_type && Koala.multipart_requires_content_type?
+      raise KoalaError.new("Unable to determine MIME type for UploadableIO") if !@content_type
     end
-    
+
     def to_upload_io
       UploadIO.new(@io_or_path, @content_type, @filename)
     end
-    
+
     def to_file
       @io_or_path.is_a?(String) ? File.open(@io_or_path) : @io_or_path
     end
-    
+
     def self.binary_content?(content)
       content.is_a?(UploadableIO) || DETECTION_STRATEGIES.detect {|method| send(method, content)}
     end
@@ -41,69 +35,81 @@ module Koala
       :rails_3_param?,
       :file_param?
     ]
-  
+
     PARSE_STRATEGIES = [
       :parse_rails_3_param,
       :parse_sinatra_param,
       :parse_file_object,
-      :parse_string_path
+      :parse_string_path,
+      :parse_io
     ]
-    
-    def parse_init_mixed_param(mixed)
+
+    def parse_init_mixed_param(mixed, content_type = nil)
       PARSE_STRATEGIES.each do |method|
-        send(method, mixed)
+        send(method, mixed, content_type)
         return if @io_or_path && @content_type
       end
     end
-    
+
     # Expects a parameter of type ActionDispatch::Http::UploadedFile
     def self.rails_3_param?(uploaded_file)
       uploaded_file.respond_to?(:content_type) and uploaded_file.respond_to?(:tempfile) and uploaded_file.tempfile.respond_to?(:path)
     end
-    
-    def parse_rails_3_param(uploaded_file)
-      if UploadableIO.rails_3_param?(uploaded_file) 
+
+    def parse_rails_3_param(uploaded_file, content_type = nil)
+      if UploadableIO.rails_3_param?(uploaded_file)
         @io_or_path = uploaded_file.tempfile.path
-        @content_type = uploaded_file.content_type
+        @content_type = content_type || uploaded_file.content_type
+        @filename = uploaded_file.original_filename
       end
     end
-    
+
     # Expects a Sinatra hash of file info
     def self.sinatra_param?(file_hash)
       file_hash.kind_of?(Hash) and file_hash.has_key?(:type) and file_hash.has_key?(:tempfile)
     end
-    
-    def parse_sinatra_param(file_hash)
+
+    def parse_sinatra_param(file_hash, content_type = nil)
       if UploadableIO.sinatra_param?(file_hash)
         @io_or_path = file_hash[:tempfile]
-        @content_type = file_hash[:type] || detect_mime_type(tempfile)
+        @content_type = content_type || file_hash[:type] || detect_mime_type(tempfile)
+        @filename = file_hash[:filename]
       end
     end
-    
+
     # takes a file object
     def self.file_param?(file)
       file.kind_of?(File)
     end
-    
-    def parse_file_object(file)
+
+    def parse_file_object(file, content_type = nil)
       if UploadableIO.file_param?(file)
         @io_or_path = file
-        @content_type = detect_mime_type(file.path)
+        @content_type = content_type || detect_mime_type(file.path)
+        @filename = File.basename(file.path)
       end
     end
-    
-    def parse_string_path(path)
+
+    def parse_string_path(path, content_type = nil)
       if path.kind_of?(String)
         @io_or_path = path
-        @content_type = detect_mime_type(path)
+        @content_type = content_type || detect_mime_type(path)
+        @filename = File.basename(path)
+      end
+    end
+
+    def parse_io(io, content_type = nil)
+      if io.respond_to?(:read)
+        @io_or_path = io
+        @content_type = content_type
       end
     end
-    
+
     MIME_TYPE_STRATEGIES = [
       :use_mime_module,
       :use_simple_detection
     ]
-    
+
     def detect_mime_type(filename)
       if filename
         MIME_TYPE_STRATEGIES.each do |method|
@@ -113,7 +119,7 @@ module Koala
       end
       nil # if we can't find anything
     end
-    
+
     def use_mime_module(filename)
       # if the user has installed mime/types, we can use that
       # if not, rescue and return nil
@@ -124,12 +130,12 @@ module Koala
         nil
       end
     end
-    
+
     def use_simple_detection(filename)
       # very rudimentary extension analysis for images
       # first, get the downcased extension, or an empty string if it doesn't exist
       extension = ((filename.match(/\.([a-zA-Z0-9]+)$/) || [])[1] || "").downcase
-      case extension 
+      case extension
         when ""
           nil
         # images
@@ -169,7 +175,7 @@ module Koala
         	"video/ogg"
         when "wmv"
         	"video/x-ms-wmv"
-      end    
+      end
     end
   end
 end

data/lib/koala/utils.rb

@@ -0,0 +1,11 @@
+module Koala
+  module Utils
+    def self.deprecate(message)
+      begin
+        send(:warn, "KOALA: Deprecation warning: #{message}")
+      rescue Exception => err
+        puts "Unable to issue Koala deprecation warning!  #{err.message}"
+      end
+    end
+  end
+end