koala 1.0.0 → 1.2.0beta1

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)["data"]
       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,11 +63,11 @@ 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
 
@@ -73,9 +85,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,115 +1,180 @@
-require 'koala'
+require "net/http/post/multipart"
 
 module Koala
   class UploadableIO
-    attr_reader :io_or_path, :content_type
+    attr_reader :io_or_path, :content_type, :filename
 
-    def initialize(io_or_path_or_mixed, content_type = nil)
+    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
-      
+      parse_init_mixed_param io_or_path_or_mixed, content_type
+
+      # filename is used in the Ads API
+      # 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, "koala-io-file.dum")
+      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
+
     private
-      PARSE_STRATEGIES = [
-        :parse_rails_3_param,
-        :parse_sinatra_param,
-        :parse_file_object,
-        :parse_string_path
-      ]
-      
-      def parse_init_mixed_param(mixed)
-        PARSE_STRATEGIES.each do |method|
-          send(method, mixed)
-          return if @io_or_path && @content_type
-        end
+    DETECTION_STRATEGIES = [
+      :sinatra_param?,
+      :rails_3_param?,
+      :file_param?
+    ]
+
+    PARSE_STRATEGIES = [
+      :parse_rails_3_param,
+      :parse_sinatra_param,
+      :parse_file_object,
+      :parse_string_path
+    ]
+
+    def parse_init_mixed_param(mixed, content_type = nil)
+      PARSE_STRATEGIES.each do |method|
+        send(method, mixed, content_type)
+        return if @io_or_path && @content_type
       end
-      
-      # Expects a parameter of type ActionDispatch::Http::UploadedFile
-      def parse_rails_3_param(uploaded_file)
-        if uploaded_file.respond_to?(:content_type) and uploaded_file.respond_to?(:tempfile) and uploaded_file.tempfile.respond_to?(:path)
-          @io_or_path = uploaded_file.tempfile.path
-          @content_type = uploaded_file.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, content_type = nil)
+      if UploadableIO.rails_3_param?(uploaded_file)
+        @io_or_path = uploaded_file.tempfile.path
+        @content_type = content_type || uploaded_file.content_type
+        @filename = uploaded_file.original_filename
       end
-      
-      # Expects a Sinatra hash of file info
-      def parse_sinatra_param(file_hash)
-        if file_hash.kind_of?(Hash) and file_hash.has_key?(:type) and file_hash.has_key?(:tempfile)
-          @io_or_path = file_hash[:tempfile]
-          @content_type = file_hash[:type] || detect_mime_type(tempfile)
-        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, content_type = nil)
+      if UploadableIO.sinatra_param?(file_hash)
+        @io_or_path = file_hash[:tempfile]
+        @content_type = content_type || file_hash[:type] || detect_mime_type(tempfile)
+        @filename = file_hash[:filename]
       end
-      
-      # takes a file object
-      def parse_file_object(file)
-        if file.kind_of?(File)
-          @io_or_path = file
-          @content_type = detect_mime_type(file.path)
-        end
+    end
+
+    # takes a file object
+    def self.file_param?(file)
+      file.kind_of?(File)
+    end
+
+    def parse_file_object(file, content_type = nil)
+      if UploadableIO.file_param?(file)
+        @io_or_path = file
+        @content_type = content_type || detect_mime_type(file.path)
+        @filename = File.basename(file.path)
       end
-      
-      def parse_string_path(path)
-        if path.kind_of?(String)
-          @io_or_path = path
-          @content_type = detect_mime_type(path)
-        end
+    end
+
+    def parse_string_path(path, content_type = nil)
+      if path.kind_of?(String)
+        @io_or_path = path
+        @content_type = content_type || detect_mime_type(path)
+        @filename = File.basename(path)
       end
-      
-      MIME_TYPE_STRATEGIES = [
-        :use_mime_module,
-        :use_simple_detection
-      ]
-      
-      def detect_mime_type(filename)
-        if filename
-          MIME_TYPE_STRATEGIES.each do |method|
-            result = send(method, filename)
-            return result if result
-          end
-        end
-        nil # if we can't find anything
+    end
+
+    def parse_io(io, content_type = nil)
+      if io.respond_to?(:read)
+        @io_or_path = io
+        @content_type = content_type
       end
-      
-      def use_mime_module(filename)
-        # if the user has installed mime/types, we can use that
-        # if not, rescue and return nil
-        begin
-          type = MIME::Types.type_for(filename).first
-          type ? type.to_s : nil
-        rescue
-          nil
+    end
+
+    MIME_TYPE_STRATEGIES = [
+      :use_mime_module,
+      :use_simple_detection
+    ]
+
+    def detect_mime_type(filename)
+      if filename
+        MIME_TYPE_STRATEGIES.each do |method|
+          result = send(method, filename)
+          return result if result
         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
-        if extension == ""
+      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
+      begin
+        type = MIME::Types.type_for(filename).first
+        type ? type.to_s : nil
+      rescue
+        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
+        when ""
           nil
-        elsif extension == "jpg" || extension == "jpeg"
+        # images
+        when "jpg", "jpeg"
           "image/jpeg"
-        elsif extension == "png"
+        when "png"
           "image/png"
-        elsif extension == "gif"
+        when "gif"
           "image/gif"
-        end
+
+        # video
+        when "3g2"
+        	"video/3gpp2"
+        when "3gp", "3gpp"
+        	"video/3gpp"
+        when "asf"
+        	"video/x-ms-asf"
+        when "avi"
+        	"video/x-msvideo"
+        when "flv"
+        	"video/x-flv"
+        when "m4v"
+        	"video/x-m4v"
+        when "mkv"
+        	"video/x-matroska"
+        when "mod"
+        	"video/mod"
+        when "mov", "qt"
+        	"video/quicktime"
+        when "mp4", "mpeg4"
+        	"video/mp4"
+        when "mpe", "mpeg", "mpg", "tod", "vob"
+        	"video/mpeg"
+        when "nsv"
+        	"application/x-winamp"
+        when "ogm", "ogv"
+        	"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