koala 1.1.0rc2 → 1.1.0rc3

data/lib/koala/graph_batch_api.rb

@@ -0,0 +1,87 @@
+module Koala
+  module Facebook
+      module GraphBatchAPIMethods
+        
+      def self.included(base)
+        base.class_eval do
+          alias_method :graph_call_outside_batch, :graph_call
+          alias_method :graph_call, :graph_call_in_batch
+          
+          alias_method :check_graph_api_response, :check_response
+          alias_method :check_response, :check_graph_batch_api_response
+        end
+      end
+      
+      def batch_calls
+        @batch_calls ||= []
+      end
+            
+      def graph_call_in_batch(path, args = {}, verb = "get", options = {}, &post_processing)
+          # for batch APIs, we queue up the call details (incl. post-processing)
+          batch_calls << BatchOperation.new(
+            :url => path,
+            :args => args,
+            :method => verb,
+            :access_token => options['access_token'] || access_token,
+            :http_options => options,
+            :post_processing => post_processing
+          )
+          nil # batch operations return nothing immediately 
+      end
+
+      def check_graph_batch_api_response(response)
+        if response.is_a?(Hash) && response["error"] && !response["error"].is_a?(Hash)
+          APIError.new("type" => "Error #{response["error"]}", "message" => response["error_description"])
+        else
+          check_graph_api_response(response)
+        end
+      end
+
+      def execute(http_options = {})
+        return [] unless batch_calls.length > 0
+        # Turn the call args collected into what facebook expects
+        args = {}
+        args["batch"] = MultiJson.encode(batch_calls.map { |batch_op|
+          args.merge!(batch_op.files) if batch_op.files
+          batch_op.to_batch_params(access_token)
+        })
+        
+        graph_call_outside_batch('/', args, 'post', http_options) do |response|
+          # map the results with post-processing included
+          index = 0 # keep compat with ruby 1.8 - no with_index for map
+          response.map do |call_result|
+            # Get the options hash
+            batch_op = batch_calls[index]
+            index += 1
+
+            if call_result
+              # (see note in regular api method about JSON parsing)
+              body = MultiJson.decode("[#{call_result['body'].to_s}]")[0]
+              
+              unless call_result["code"].to_i >= 500 || error = check_response(body)
+                # Get the HTTP component they want
+                data = case batch_op.http_options[:http_component] 
+                when :status
+                  call_result["code"].to_i
+                when :headers
+                  # facebook returns the headers as an array of k/v pairs, but we want a regular hash
+                  call_result['headers'].inject({}) { |headers, h| headers[h['name']] = h['value']; headers}
+                else
+                  body
+                end
+
+                # process it if we are given a block to process with
+                batch_op.post_processing ? batch_op.post_processing.call(data) : data
+              else
+                error || APIError.new({"type" => "HTTP #{call_result["code"].to_s}", "message" => "Response body: #{body}"})
+              end
+            else
+              nil
+            end
+          end          
+        end
+      end
+      
+    end
+  end
+end

data/lib/koala/graph_collection.rb

@@ -0,0 +1,54 @@
+module Koala
+  module Facebook
+    class GraphCollection < Array
+      # This class is a light wrapper for collections returned
+      # from the Graph API.
+      #
+      # It extends Array to allow direct access to the data colleciton
+      # which should allow it to drop in seamlessly.
+      #
+      # It also allows access to paging information and the
+      # ability to get the next/previous page in the collection
+      # by calling next_page or previous_page.
+      attr_reader :paging
+      attr_reader :api
+      
+      def initialize(response, api)
+        super response["data"]
+        @paging = response["paging"]
+        @api = api
+      end
+            
+      # defines methods for NEXT and PREVIOUS pages
+      %w{next previous}.each do |this|
+        
+        # def next_page
+        # def previous_page
+        define_method "#{this.to_sym}_page" do
+          base, args = send("#{this}_page_params")
+          base ? @api.get_page([base, args]) : nil
+        end
+        
+        # def next_page_params
+        # def previous_page_params
+        define_method "#{this.to_sym}_page_params" do
+          return nil unless @paging and @paging[this]
+          parse_page_url(@paging[this])
+        end
+      end
+      
+      def parse_page_url(url)
+        match = url.match(/.com\/(.*)\?(.*)/)
+        base = match[1]
+        args = match[2]
+        params = CGI.parse(args)
+        new_params = {}
+        params.each_pair do |key,value|
+          new_params[key] = value.join ","
+        end
+        [base,new_params]
+      end
+      
+    end
+  end
+end

data/lib/koala/http_services.rb

@@ -13,18 +13,20 @@ module Koala
     def self.included(base)
       base.class_eval do
         class << self
-          attr_accessor :always_use_ssl, :proxy, :timeout, :ca_path, :ca_file
+          attr_accessor :always_use_ssl, :proxy, :timeout
         end
 
         def self.server(options = {})
-          "#{options[:beta] ? "beta." : ""}#{options[:rest_api] ? Facebook::REST_SERVER : Facebook::GRAPH_SERVER}"          
+          server = "#{options[:rest_api] ? Facebook::REST_SERVER : Facebook::GRAPH_SERVER}"
+          server.gsub!(/\.facebook/, "-video.facebook") if options[:video]
+          "#{options[:beta] ? "beta." : ""}#{server}"
         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
           ((param_hash || {}).collect do |key_and_value|
-            key_and_value[1] = key_and_value[1].to_json unless key_and_value[1].is_a? String
+            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

data/lib/koala/http_services/net_http_service.rb

@@ -7,6 +7,11 @@ module Koala
     # this service uses Net::HTTP to send requests to the graph
     include Koala::HTTPService
 
+    # Net::HTTP-specific values
+    class << self
+      attr_accessor :ca_file, :ca_path, :verify_mode
+    end
+    
     def self.make_request(path, args, verb, options = {})
       # We translate args to a valid query string. If post is specified,
       # we send a POST request to the given path with the given arguments.
@@ -15,17 +20,13 @@ module Koala
       # this makes public requests faster
       private_request = args["access_token"] || @always_use_ssl || options[:use_ssl]
 
-      # if proxy/timeout options aren't passed, check if defaults are set
-      options[:proxy] ||= proxy
-      options[:timeout] ||= timeout
-
       # 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"
 
       http = create_http(server(options), private_request, options)
 
-      result = http.start do |http|
-        response, body = if verb == "post"
+      response = http.start do |http|
+        if verb == "post"
           if params_require_multipart? args
             http.request Net::HTTP::Post::Multipart.new path, encode_multipart_params(args)
           else
@@ -34,9 +35,9 @@ module Koala
         else
           http.get("#{path}?#{encode_params(args)}")
         end
-      
-        Koala::Response.new(response.code.to_i, body, response)
       end
+
+      Koala::Response.new(response.code.to_i, response.body, response)
     end
 
     protected
@@ -44,44 +45,48 @@ module Koala
       # unfortunately, we can't use to_query because that's Rails, not Ruby
       # if no hash (e.g. no auth token) return empty string
       ((param_hash || {}).collect do |key_and_value|
-        key_and_value[1] = key_and_value[1].to_json if key_and_value[1].class != String
+        key_and_value[1] = MultiJson.encode(key_and_value[1]) if key_and_value[1].class != String
         "#{key_and_value[0].to_s}=#{CGI.escape key_and_value[1]}"
       end).join("&")
     end
-  
+
     def self.encode_multipart_params(param_hash)
-      Hash[*param_hash.collect do |key, value| 
+      Hash[*param_hash.collect do |key, value|
         [key, value.kind_of?(Koala::UploadableIO) ? value.to_upload_io : value]
       end.flatten]
     end
 
     def self.create_http(server, private_request, options)
-      if options[:proxy]
-        proxy = URI.parse(options[:proxy])
+      if proxy_server = options[:proxy] || proxy
+        proxy = URI.parse(proxy_server)
         http  = Net::HTTP.new(server, private_request ? 443 : nil,
                               proxy.host, proxy.port, proxy.user, proxy.password)
       else
-        http = Net::HTTP.new(server, private_request ? 443 : nil)
+        http  = Net::HTTP.new(server, private_request ? 443 : nil)
       end
-      
-      if options[:timeout]
-        http.open_timeout = options[:timeout]
-        http.read_timeout = options[:timeout]
+
+      if timeout_value = options[:timeout] || timeout
+        http.open_timeout = timeout_value
+        http.read_timeout = timeout_value
       end
-      
+
       # For HTTPS requests, set the proper CA certificates
       if private_request
         http.use_ssl = true  
-        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.verify_mode = options[:verify_mode] || verify_mode || OpenSSL::SSL::VERIFY_PEER
         
-        options[:ca_file] ||= ca_file
-        http.ca_file = options[:ca_file] if options[:ca_file] && File.exists?(options[:ca_file])
+        if cert_file = options[:ca_file] || ca_file
+          raise Errno::ENOENT, "Certificate file #{cert_file.inspect} does not exist!" unless File.exists?(cert_file)
+          http.ca_file = cert_file 
+        end
         
-        options[:ca_path] ||= ca_path
-        http.ca_path = options[:ca_path] if options[:ca_path] && Dir.exists?(options[:ca_path])
+        if cert_path = options[:ca_path] || ca_path
+          raise Errno::ENOENT, "Certificate path #{cert_path.inspect} does not exist!" unless File.directory?(cert_path)
+          http.ca_path = cert_path
+        end
       end
-            
+
       http
     end
   end
-end
+end

data/lib/koala/http_services/typhoeus_service.rb

@@ -3,14 +3,14 @@ require "typhoeus" unless defined?(Typhoeus)
 module Koala
   module TyphoeusService
     # this service uses Typhoeus to send requests to the graph
-    include Typhoeus  
+    include Typhoeus
     include Koala::HTTPService
 
     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"
 
-      # switch any UploadableIOs to the files Typhoeus expects 
+      # switch any UploadableIOs to the files Typhoeus expects
       args.each_pair {|key, value| args[key] = value.to_file if value.is_a?(UploadableIO)}
 
       # you can pass arguments directly to Typhoeus using the :typhoeus_options key
@@ -27,9 +27,9 @@ module Koala
       response = Typhoeus::Request.send(verb, "#{prefix}://#{server(options)}#{path}", typhoeus_options)
       Koala::Response.new(response.code, response.body, response.headers_hash)
     end
-  
+
     protected
-      
+
     def self.multipart_requires_content_type?
       false # Typhoeus handles multipart file types, we don't have to require it
     end

data/lib/koala/oauth.rb

@@ -99,7 +99,7 @@ module Koala
       def parse_signed_request(input)
         encoded_sig, encoded_envelope = input.split('.', 2)
         signature = base64_url_decode(encoded_sig).unpack("H*").first
-        envelope = JSON.parse(base64_url_decode(encoded_envelope))
+        envelope = MultiJson.decode(base64_url_decode(encoded_envelope))
 
         raise "SignedRequest: Unsupported algorithm #{envelope['algorithm']}" if envelope['algorithm'] != 'HMAC-SHA256'
 
@@ -126,7 +126,7 @@ module Koala
           })
         end
 
-        JSON.parse(response)
+        MultiJson.decode(response)
       end
 
       def get_tokens_from_session_keys(sessions, options = {})
@@ -149,7 +149,7 @@ module Koala
         result = fetch_token_string(args, post, "access_token", options)
 
         # if we have an error, parse the error JSON and raise an error
-        raise APIError.new((JSON.parse(result)["error"] rescue nil) || {}) if result =~ /error/
+        raise APIError.new((MultiJson.decode(result)["error"] rescue nil) || {}) if result =~ /error/
 
         # otherwise, parse the access token
         parse_access_token(result)

data/lib/koala/rest_api.rb

@@ -8,7 +8,7 @@ module Koala
       end
 
       def fql_multiquery(queries = {}, args = {}, options = {})
-        if results = rest_call('fql.multiquery', args.merge(:queries => queries.to_json), options)
+        if results = rest_call('fql.multiquery', args.merge(:queries => MultiJson.encode(queries)), options)
           # simplify the multiquery result format
           results.inject({}) {|outcome, data| outcome[data["name"]] = data["fql_result_set"]; outcome}
         end

data/lib/koala/uploadable_io.rb

@@ -36,108 +36,140 @@ module Koala
     end
 
     private
-      DETECTION_STRATEGIES = [
-        :sinatra_param?,
-        :rails_3_param?,
-        :file_param?
-      ]
+    DETECTION_STRATEGIES = [
+      :sinatra_param?,
+      :rails_3_param?,
+      :file_param?
+    ]
+  
+    PARSE_STRATEGIES = [
+      :parse_rails_3_param,
+      :parse_sinatra_param,
+      :parse_file_object,
+      :parse_string_path
+    ]
     
-      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
-      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) 
-          @io_or_path = uploaded_file.tempfile.path
-          @content_type = uploaded_file.content_type
-        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)
+    def parse_init_mixed_param(mixed)
+      PARSE_STRATEGIES.each do |method|
+        send(method, mixed)
+        return if @io_or_path && @content_type
       end
-      
-      def parse_sinatra_param(file_hash)
-        if UploadableIO.sinatra_param?(file_hash)
-          @io_or_path = file_hash[:tempfile]
-          @content_type = file_hash[:type] || detect_mime_type(tempfile)
-        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) 
+        @io_or_path = uploaded_file.tempfile.path
+        @content_type = uploaded_file.content_type
       end
-      
-      # takes a file object
-      def self.file_param?(file)
-        file.kind_of?(File)
+    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)
+      if UploadableIO.sinatra_param?(file_hash)
+        @io_or_path = file_hash[:tempfile]
+        @content_type = file_hash[:type] || detect_mime_type(tempfile)
       end
-      
-      def parse_file_object(file)
-        if UploadableIO.file_param?(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)
+      if UploadableIO.file_param?(file)
+        @io_or_path = file
+        @content_type = detect_mime_type(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)
+      if path.kind_of?(String)
+        @io_or_path = path
+        @content_type = detect_mime_type(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
+    
+    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
-        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
+      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
-      
-      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 == ""
+    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
-      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