koala 1.1.0rc → 1.1.0rc3

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/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/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

data/lib/koala.rb

@@ -1,7 +1,7 @@
 require 'cgi'
 require 'digest/md5'
 
-require 'json'
+require 'multi_json'
 
 # OpenSSL and Base64 are required to support signed_request
 require 'openssl'
@@ -12,7 +12,9 @@ require 'koala/http_services'
 require 'koala/http_services/net_http_service'
 require 'koala/oauth'
 require 'koala/graph_api'
-require 'koala/graph_api_batch'
+require 'koala/graph_batch_api'
+require 'koala/batch_operation'
+require 'koala/graph_collection'
 require 'koala/rest_api'
 require 'koala/realtime_updates'
 require 'koala/test_users'
@@ -53,8 +55,8 @@ module Koala
 
         # parse the body as JSON and run it through the error checker (if provided)
         # Note: Facebook sometimes sends results like "true" and "false", which aren't strictly objects
-        # and cause JSON.parse to fail -- so we account for that by wrapping the result in []
-        body = JSON.parse("[#{result.body.to_s}]")[0]
+        # and cause MultiJson.decode to fail -- so we account for that by wrapping the result in []
+        body = MultiJson.decode("[#{result.body.to_s}]")[0]
         yield body if error_checking_block
 
         # if we want a component other than the body (e.g. redirect header for images), return that
@@ -66,9 +68,12 @@ module Koala
     
     class GraphAPI < API
       include GraphAPIMethods
-      include GraphAPIBatchMethods
     end
     
+    class GraphBatchAPI < GraphAPI
+      include GraphBatchAPIMethods      
+    end
+        
     class RestAPI < API
       include RestAPIMethods
     end

data/readme.md

@@ -1,9 +1,9 @@
 Koala
 ====
-Koala (<a href="http://github.com/arsduo/koala" target="_blank">http://github.com/arsduo/koala</a>) is a new Facebook library for Ruby, supporting the Graph API (including the batch requests and photo uploads), the REST API, realtime updates, test users, and OAuth validation.  We wrote Koala with four goals:
+[Koala](http://github.com/arsduo/koala) is a new Facebook library for Ruby, supporting the Graph API (including the batch requests and photo uploads), the REST API, realtime updates, test users, and OAuth validation.  We wrote Koala with four goals:
 
-* Lightweight: Koala should be as light and simple as Facebook’s own new libraries, providing API accessors and returning simple JSON.  (We clock in, with comments, just over 750 lines of code.)
-* Fast: Koala should, out of the box, be quick. In addition to supporting the vanilla Ruby networking libraries, it natively supports Typhoeus, our preferred gem for making fast HTTP requests. Of course, That brings us to our next topic:
+* Lightweight: Koala should be as light and simple as Facebook’s own new libraries, providing API accessors and returning simple JSON.  (We clock in, with comments, at just over 750 lines of code.)
+* Fast: Koala should, out of the box, be quick. In addition to supporting the vanilla Ruby networking libraries, it natively supports Typhoeus, our preferred gem for making fast HTTP requests. Of course, that brings us to our next topic:
 * Flexible: Koala should be useful to everyone, regardless of their current configuration.  (We have no dependencies beyond the JSON gem.  Koala also has a built-in mechanism for using whichever HTTP library you prefer to make requests against the graph.)
 * Tested: Koala should have complete test coverage, so you can rely on it.  (Our complete test coverage can be run against either mocked responses or the live Facebook servers.)
 
@@ -47,7 +47,7 @@ When retrieving data that returns an array of results (for example, when calling
     # This is useful for paging across multiple requests
     next_path, next_args = feed.next_page_params
 
-    # You can use those params to easily get the next (or prevous) page
+    # You can use those params to easily get the next (or previous) page
     page = graph.get_page(feed.next_page_params)
 
 You can make multiple calls at once using Facebook's batch API:
@@ -144,12 +144,12 @@ Testing
 Unit tests are provided for all of Koala's methods.  By default, these tests run against mock responses and hence are ready out of the box:
     
     # From anywhere in the project directory:
-    rake spec
+    bundle exec rake spec
     
 
 You can also run live tests against Facebook's servers:
     
     # Again from anywhere in the project directory:
-    LIVE=true rake spec
+    LIVE=true bundle exec rake spec
 
-Important Note: to run the live tests, you have to provide some of your own data in spec/fixtures/facebook_data.yml: a valid OAuth access token with publish\_stream, read\_stream, and user\_photos permissions and an OAuth code that can be used to generate an access token.  You can get thisdata at the OAuth Playground; if you want to use your own app, remember to swap out the app ID, secret, and other values.  (The file also provides valid values for other tests, which you're welcome to swap out for data specific to your own application.)
+Important Note: to run the live tests, you have to provide some of your own data in spec/fixtures/facebook_data.yml: a valid OAuth access token with publish\_stream, read\_stream, and user\_photos permissions and an OAuth code that can be used to generate an access token.  You can get this data at the OAuth Playground; if you want to use your own app, remember to swap out the app ID, secret, and other values.  (The file also provides valid values for other tests, which you're welcome to swap out for data specific to your own application.)

data/spec/cases/api_base_spec.rb

@@ -52,7 +52,7 @@ describe "Koala::Facebook::API" do
     Koala.stub(:make_request).and_return(response)
 
     json_body = mock('JSON body')
-    JSON.stub(:parse).and_return([json_body])
+    MultiJson.stub(:decode).and_return([json_body])
 
     @service.api('anything').should == json_body
   end
@@ -66,7 +66,7 @@ describe "Koala::Facebook::API" do
 
     @service.api('anything', {}, "get") do |arg|
       yield_test.pass
-      arg.should == JSON.parse(body)
+      arg.should == MultiJson.decode(body)
     end
   end