koala 1.1.0rc2 → 1.1.0rc3

data/spec/cases/oauth_spec.rb

@@ -391,7 +391,7 @@ describe "Koala::Facebook::OAuth" do
     # the signed request code is ported directly from Facebook
     # so we only need to test at a high level that it works      
     it "should throw an error if the algorithm is unsupported" do
-      JSON.stub!(:parse).and_return("algorithm" => "my fun algorithm")
+      MultiJson.stub(:decode).and_return("algorithm" => "my fun algorithm")
       lambda { @oauth.parse_signed_request(@signed_request) }.should raise_error
     end
     

data/spec/cases/realtime_updates_spec.rb

@@ -43,19 +43,19 @@ describe "Koala::Facebook::RealtimeUpdates" do
     it "should not allow write access to app_id" do
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
       # this should not throw errors
-      lambda { updates.app_id = 2 }.should raise_error(NoMethodError)
+      updates.methods.map(&:to_sym).should_not include(:app_id=)
     end
 
     it "should not allow write access to app_access_token" do
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
       # this should not throw errors
-      lambda { updates.app_access_token = 2 }.should raise_error(NoMethodError)
+      updates.methods.map(&:to_sym).should_not include(:app_access_token=)
     end
   
     it "should not allow write access to secret" do
       updates = Koala::Facebook::RealtimeUpdates.new(:app_id => @app_id, :app_access_token => @app_access_token)
       # this should not throw errors
-      lambda { updates.secret = 2 }.should raise_error(NoMethodError)
+      updates.methods.map(&:to_sym).should_not include(:secret=)
     end
     
     # init with secret / fetching the token

data/spec/fixtures/mock_facebook_responses.yml

@@ -25,11 +25,11 @@ rest_api:
         no_token: '{"error_code":104,"error_msg":"Requires valid signature","request_args":[{"key":"method","value":"fql.query"},{"key":"format","value":"json"},{"key":"query","value":"select read_stream from permissions where uid = 216743"}]}'
 
   /method/fql.multiquery:
-    'queries={"query1":"select post_id from stream where source_id = me()","query2":"select fromid from comment where post_id in (select post_id from #query1)","query3":"select uid, name from user where uid in (select fromid from #query2)"}':
+    'queries=<%= MultiJson.encode({"query1" => "select post_id from stream where source_id = me()", "query2" => "select fromid from comment where post_id in (select post_id from #query1)", "query3" => "select uid, name from user where uid in (select fromid from #query2)"}) %>':
       get: 
         with_token: '[{"name":"query1", "fql_result_set":[]},{"name":"query2", "fql_result_set":[]},{"name":"query3", "fql_result_set":[]}]'
         no_token: '{"error_code":104,"error_msg":"Requires valid signature","request_args":[{"key":"method","value":"fql.query"},{"key":"format","value":"json"},{"key":"query","value":"select read_stream from permissions where uid = 216743"}]}'
-    'queries={"query1":"select first_name from user where uid = 216743","query2":"select first_name from user where uid = 2905623"}':
+    'queries=<%= MultiJson.encode({"query1" => "select first_name from user where uid = 216743", "query2" => "select first_name from user where uid = 2905623"}) %>':
       get:
         with_token: '[{"name":"query1", "fql_result_set":[{"first_name":"Chris"}]},{"name":"query2", "fql_result_set":[{"first_name":"Alex"}]}]' 
         no_token: '[{"name":"query1", "fql_result_set":[{"first_name":"Chris"}]},{"name":"query2", "fql_result_set":[{"first_name":"Alex"}]}]'
@@ -74,52 +74,53 @@ graph_api:
         with_token: '{"contextoptional":"{}","naitik":"{}"}'
         no_token: '{"contextoptional":"{}","naitik":"{}"}'
     # Ruby 1.8.7 and 1.9.2 generate JSON with different key ordering, hence we have to dynamically generate it here 
-    batch=<%= [{"method" => "get", "relative_url" => "me"},{"method" => "get", "relative_url" => "koppel"}].to_json %>:
+    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me"},{"method" => "get", "relative_url" => "koppel"}]) %>:
       post:
         with_token: '[{"body":"{\"id\":\"123\"}"}, {"body":"{\"id\":\"456\"}"}]'
-    batch=<%= [{"method" => "get", "relative_url" => "me/picture"}].to_json %>:
+    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me/picture"}]) %>:
       post:
         with_token: '[{"headers":[{"name":"Location","value":"http://google.com"}]}]'
-    batch=<%= [{"method" => "get", "relative_url" => "me"},{"method" => "get", "relative_url" => "me/friends"}].to_json %>:
+    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me"},{"method" => "get", "relative_url" => "me/friends"}]) %>:
       post:
         with_token: '[{"body":"{\"id\":\"123\"}"}, {"body":"{\"data\":[]}"}]'
-    batch=<%= [{"method"=>"get", "relative_url"=>"me"}, {"method"=>"get", "relative_url"=>"#{OAUTH_DATA["app_id"]}/insights?access_token=#{CGI.escape APP_ACCESS_TOKEN}"}].to_json %>:
+    batch=<%= MultiJson.encode([{"method"=>"get", "relative_url"=>"me"}, {"method"=>"get", "relative_url"=>"#{OAUTH_DATA["app_id"]}/insights?access_token=#{CGI.escape APP_ACCESS_TOKEN}"}]) %>:
       post:
         with_token: '[{"body":"{\"id\":\"123\"}"}, {"body":"{\"data\":[]}"}]'
-    batch=<%= [{"method"=>"get", "relative_url"=>"#{OAUTH_DATA["app_id"]}/insights"}, {"method"=>"get", "relative_url"=>"koppel?access_token=#{CGI.escape APP_ACCESS_TOKEN}"}].to_json %>:
+    batch=<%= MultiJson.encode([{"method"=>"get", "relative_url"=>"#{OAUTH_DATA["app_id"]}/insights"}, {"method"=>"get", "relative_url"=>"koppel?access_token=#{CGI.escape APP_ACCESS_TOKEN}"}]) %>:
       post:
         with_token: '[{"body": "{\"error\":{\"type\":\"AnError\", \"message\":\"An error occurred!.\"}}"},{"body":"{\"id\":\"123\"}"}]'
-    batch=<%= [{"method"=>"post", "relative_url"=>"FEED_ITEM_BATCH/likes"}, {"method"=>"delete", "relative_url"=> "FEED_ITEM_BATCH"}].to_json %>:
+    batch=<%= MultiJson.encode([{"method"=>"post", "relative_url"=>"FEED_ITEM_BATCH/likes"}, {"method"=>"delete", "relative_url"=> "FEED_ITEM_BATCH"}]) %>:
       post:
         with_token: '[{"body": "{\"id\": \"MOCK_LIKE\"}"},{"body":true}]'
-    batch=<%= [{"method" => "get", "relative_url" => "me/friends?limit=5", "name" => "get-friends"}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=get-friends:$.data.*.id}"}"}].to_json %>:
+    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me/friends?limit=5", "name" => "get-friends"}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=get-friends:$.data.*.id}"}"}]) %>:
       post:
         with_token: '[null,{"body":"{}"}]'
-    batch=<%= [{"method" => "get", "relative_url" => "me/friends?limit=5", "name" => "get-friends", "omit_response_on_success" => false}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=get-friends:$.data.*.id}"}"}].to_json %>:
+    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me/friends?limit=5", "name" => "get-friends", "omit_response_on_success" => false}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=get-friends:$.data.*.id}"}"}]) %>:
       post:
         with_token: '[{"body":"{\"data\":[]}"},{"body":"{}"}]'
-    batch=<%= [{"method" => "get", "relative_url" => "me/friends?limit=5"}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=i-dont-exist:$.data.*.id}"}"}].to_json %>:
+    batch=<%= MultiJson.encode([{"method" => "get", "relative_url" => "me/friends?limit=5"}, {"method" => "get", "relative_url" => "?ids=#{CGI.escape "{result=i-dont-exist:$.data.*.id}"}"}]) %>:
       post:
         with_token: '{"error":190,"error_description":"Error validating access token."}'
-    batch=<%= [{"method" => "post", "relative_url" => "method/fql.query", "body" => "query=select+name+from+user+where+uid%3D4"}].to_json %>:
+    batch=<%= MultiJson.encode([{"method" => "post", "relative_url" => "method/fql.query", "body" => "query=select+name+from+user+where+uid%3D4"}]) %>:
       post:
         with_token: '[{"body":"[{\"name\":\"Mark Zuckerberg\"}]"}]'
-    batch=<%= [{"method"=>"get", "relative_url"=>"me", "name" => "getme"}, {"method"=>"get", "relative_url"=>"koppel", "depends_on" => "getme"}].to_json %>:
-      post:
-        with_token: '[null,{"body":"{\"id\":\"123\"}"}]'
-    batch=<%= [{"method"=>"get", "relative_url"=>"#{OAUTH_DATA["app_id"]}/insights", "name" => "getdata"}, {"method"=>"get", "relative_url"=>"koppel", "depends_on" => "getdata"}].to_json %>:
-      post:
-        with_token: '[{"body": "{\"error\":{\"type\":\"AnError\", \"message\":\"An error occurred!.\"}}"},null]'
-    batch=<%= [{"method"=>"get", "relative_url"=>"#{OAUTH_DATA["app_id"]}/insights", "name" => "getdata"}, {"method"=>"get", "relative_url"=>"koppel", "depends_on" => "getdata"}].to_json %>:
+      
+    # dependencies
+    batch=<%= MultiJson.encode([{"method"=>"get", "relative_url"=>"me", "name" => "getme"}, {"method"=>"get", "relative_url"=>"koppel", "depends_on" => "getme"}]) %>:
+      post: &batch_dependent
+        with_token: '[null,{"body":"{\"id\":\"123\"}"}]'  
+    batch=<%= MultiJson.encode([{"method"=>"get", "relative_url"=>"#{OAUTH_DATA["app_id"]}/insights", "name" => "getdata"}, {"method"=>"get", "relative_url"=>"koppel", "depends_on" => "getdata"}]) %>:
       post:
         with_token: '[{"body": "{\"error\":{\"type\":\"AnError\", \"message\":\"An error occurred!.\"}}"},null]'
-    batch=<%= [{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "file0_0"}].to_json %>&file0_0=[FILE]:
+  
+    # attached files tests
+    batch=<%= MultiJson.encode([{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "op1_file0"}]) %>&op1_file0=[FILE]:
       post:
         with_token: '[{"body": "{\"error\":{\"type\":\"AnError\", \"message\":\"An error occurred!.\"}}"},null]'
-    batch=<%= [{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "file0_0"}].to_json %>&file0_0=[FILE]:
+    batch=<%= MultiJson.encode([{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "op1_file0"}]) %>&op1_file0=[FILE]:
       post:
         with_token: '[{"body":"{\"id\": \"MOCK_PHOTO\"}"}]'
-    batch=<%= [{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "file0_0"}, {"method"=>"post", "relative_url"=>"koppel/photos", "attached_files" => "file1_0"}].to_json %>&file0_0=[FILE]&file1_0=[FILE]:
+    batch=<%= MultiJson.encode([{"method"=>"post", "relative_url"=>"me/photos", "attached_files" => "op1_file0"}, {"method"=>"post", "relative_url"=>"koppel/photos", "attached_files" => "op2_file0"}]) %>&op1_file0=[FILE]&op2_file0=[FILE]:
       post:
         with_token: '[{"body":"{\"id\": \"MOCK_PHOTO\"}"}, {"body":"{\"id\": \"MOCK_PHOTO\"}"}]'
 
@@ -161,6 +162,16 @@ graph_api:
       post:
         <<: *token_required
         with_token: '{"id": "MOCK_PHOTO"}'
+  /me/videos:
+    source=[FILE]:
+      post:
+        <<: *token_required
+        with_token: '{"id": "MOCK_PHOTO"}'
+    message=This is the test message&source=[FILE]:
+      post:
+        <<: *token_required
+        with_token: '{"id": "MOCK_PHOTO"}'
+
   /koppel:
     no_args:
       get:

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 begin
   require 'bundler/setup'
 rescue LoadError
-  puts 'although not required, bundler is recommened for running the tests'
+  puts 'although not required, bundler is recommended for running the tests'
 end
 
 # load the libraries

data/spec/support/graph_api_shared_examples.rb

@@ -166,44 +166,87 @@ shared_examples_for "Koala GraphAPI with an access token" do
     @temporary_object_id.should_not be_nil
   end
 
-  it "should be able to post photos to the user's wall with an open file object" do
-    content_type = "image/jpg"      
-    file = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
-    
-    result = @api.put_picture(file, content_type)
-    @temporary_object_id = result["id"] 
-    @temporary_object_id.should_not be_nil
-  end
+  describe ".put_picture" do
+    it "should be able to post photos to the user's wall with an open file object" do
+      content_type = "image/jpg"      
+      file = File.open(File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg"))
   
-  it "uses the base HTTP service if the upload is a StringIO or similar" do
-    source = stub("UploadIO")
-    Koala::UploadableIO.stub(:new).and_return(source)
-    source.stub(:requires_base_http_service).and_return(true)
-    Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(:http_service => Koala.base_http_service)).and_return(Koala::Response.new(200, "[]", {}))
-    @api.put_picture(StringIO.new)
-  end
+      result = @api.put_picture(file, content_type)
+      @temporary_object_id = result["id"] 
+      @temporary_object_id.should_not be_nil
+    end
+
+    it "uses the base HTTP service if the upload is a StringIO or similar" do
+      source = stub("UploadIO")
+      Koala::UploadableIO.stub(:new).and_return(source)
+      source.stub(:requires_base_http_service).and_return(true)
+      Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(:http_service => Koala.base_http_service)).and_return(Koala::Response.new(200, "[]", {}))
+      @api.put_picture(StringIO.new)
+    end
+
+    it "should be able to post photos to the user's wall without an open file object" do
+      content_type = "image/jpg",
+      file_path = File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")
   
-  it "should be able to post photos to the user's wall without an open file object" do
-    content_type = "image/jpg",
-    file_path = File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")
-    
-    result = @api.put_picture(file_path, content_type)
-    @temporary_object_id = result["id"] 
-    @temporary_object_id.should_not be_nil
+      result = @api.put_picture(file_path, content_type)
+      @temporary_object_id = result["id"] 
+      @temporary_object_id.should_not be_nil
+    end
+  
+    it "should be able to verify a photo posted to a user's wall" do
+      content_type = "image/jpg",
+      file_path = File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")
+  
+      expected_message = "This is the test message"
+  
+      result = @api.put_picture(file_path, content_type, :message => expected_message)
+      @temporary_object_id = result["id"] 
+      @temporary_object_id.should_not be_nil
+  
+      get_result = @api.get_object(@temporary_object_id)
+      get_result["name"].should == expected_message
+    end
   end
+  
+  describe ".put_video" do
+    before :each do
+      @cat_movie = File.join(File.dirname(__FILE__), "..", "fixtures", "cat.m4v")      
+      @content_type = "video/mpeg4"      
+    end
     
-  it "should be able to verify a photo posted to a user's wall" do
-    content_type = "image/jpg",
-    file_path = File.join(File.dirname(__FILE__), "..", "fixtures", "beach.jpg")
-    
-    expected_message = "This is the test message"
-    
-    result = @api.put_picture(file_path, content_type, :message => expected_message)
-    @temporary_object_id = result["id"] 
-    @temporary_object_id.should_not be_nil
+    it "should set options[:video] to true" do
+      source = stub("UploadIO")
+      Koala::UploadableIO.stub(:new).and_return(source)
+      source.stub(:requires_base_http_service).and_return(false)
+      Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(:video => true)).and_return(Koala::Response.new(200, "[]", {}))
+      @api.put_video("foo")
+    end
     
-    get_result = @api.get_object(@temporary_object_id)
-    get_result["name"].should == expected_message
+    it "should be able to post videos to the user's wall with an open file object" do
+      file = File.open(@cat_movie)
+
+      result = @api.put_video(file, @content_type)
+      @temporary_object_id = result["id"] 
+      @temporary_object_id.should_not be_nil
+    end
+
+    it "uses the base HTTP service if the upload is a StringIO or similar" do
+      source = stub("UploadIO")
+      Koala::UploadableIO.stub(:new).and_return(source)
+      source.stub(:requires_base_http_service).and_return(true)
+      Koala.should_receive(:make_request).with(anything, anything, anything, hash_including(:http_service => Koala.base_http_service)).and_return(Koala::Response.new(200, "[]", {}))
+      @api.put_video(StringIO.new)
+    end
+
+    it "should be able to post videos to the user's wall without an open file object" do
+      result = @api.put_video(@cat_movie, @content_type)
+      @temporary_object_id = result["id"] 
+      @temporary_object_id.should_not be_nil
+    end
+
+    # note: Facebook doesn't post videos immediately to the wall, due to processing time
+    # during which get_object(video_id) will return false
+    # hence we can't do the same verify test we do for photos
   end
 
   it "should be able to verify a message with an attachment posted to a feed" do
@@ -267,6 +310,7 @@ shared_examples_for "Koala GraphAPI with an access token" do
       :search => 3,
       # methods that have special arguments
       :put_picture => ["x.jpg", "image/jpg", {}, "me"],
+      :put_video => ["x.mp4", "video/mpeg4", {}, "me"],
       :get_objects => [["x"], {}]
     }.each_pair do |method_name, params|
       it "should pass http options through for #{method_name}" do
@@ -343,8 +387,8 @@ shared_examples_for "Koala GraphAPI with GraphCollection" do
       end
 
       it "should have a read-only paging attribute" do
-        lambda { @result.paging }.should_not raise_error
-        lambda { @result.paging = "paging" }.should raise_error(NoMethodError)
+        @result.methods.map(&:to_sym).should include(:paging)
+        @result.methods.map(&:to_sym).should_not include(:paging=)
       end
 
       describe "when getting a whole page" do

data/spec/support/mock_http_service.rb

@@ -5,6 +5,9 @@ module Koala
   module MockHTTPService
     include Koala::HTTPService
 
+    # fix our specs to use ok_json, so we always get the same results from to_json
+    MultiJson.engine = :ok_json
+
     # Mocks all HTTP requests for with koala_spec_with_mocks.rb
     # Mocked values to be included in TEST_DATA used in specs
     ACCESS_TOKEN = '*'

data/spec/support/rest_api_shared_examples.rb

@@ -154,13 +154,13 @@ shared_examples_for "Koala RestAPI" do
           "fql.multiquery", anything, anything
         ).and_return({})
 
-        @api.fql_multiquery stub('query string')
+        @api.fql_multiquery 'query string'
       end
 
       it "should pass a queries argument" do
         queries = stub('query string')
         queries_json = "some JSON"
-        queries.stub(:to_json).and_return(queries_json)
+        MultiJson.stub(:encode).with(queries).and_return(queries_json)
         
         @api.should_receive(:rest_call).with(
           anything,

data/spec/support/setup_mocks_or_live.rb

@@ -4,8 +4,7 @@ module KoalaTest
     print "Validating permissions for live testing..."
     # make sure we have the necessary permissions
     api = Koala::Facebook::GraphAndRestAPI.new(token)
-    uid = api.get_object("me")["id"]
-    perms = api.fql_query("select read_stream, publish_stream, user_photos, read_insights from permissions where uid = #{uid}")[0]
+    perms = api.fql_query("select read_stream, publish_stream, user_photos, user_videos, read_insights from permissions where uid = me()")[0]
     perms.each_pair do |perm, value|
       if value == (perm == "read_insights" ? 1 : 0) # live testing depends on insights calls failing 
         puts "failed!\n" # put a new line after the print above

metadata

@@ -2,7 +2,7 @@
 name: koala
 version: !ruby/object:Gem::Version 
   prerelease: 5
-  version: 1.1.0rc2
+  version: 1.1.0rc3
 platform: ruby
 authors: 
 - Alex Koppel, Chris Baclig, Rafi Jacoby, Context Optional
@@ -10,11 +10,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-06 00:00:00 +02:00
+date: 2011-06-30 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: json
+  name: multi_json
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -80,6 +80,7 @@ extra_rdoc_files:
 files: 
 - .autotest
 - .gitignore
+- .travis.yml
 - CHANGELOG
 - Gemfile
 - LICENSE
@@ -88,8 +89,10 @@ files:
 - autotest/discover.rb
 - koala.gemspec
 - lib/koala.rb
+- lib/koala/batch_operation.rb
 - lib/koala/graph_api.rb
-- lib/koala/graph_api_batch.rb
+- lib/koala/graph_batch_api.rb
+- lib/koala/graph_collection.rb
 - lib/koala/http_services.rb
 - lib/koala/http_services/net_http_service.rb
 - lib/koala/http_services/typhoeus_service.rb
@@ -113,6 +116,7 @@ files:
 - spec/cases/test_users_spec.rb
 - spec/cases/uploadable_io_spec.rb
 - spec/fixtures/beach.jpg
+- spec/fixtures/cat.m4v
 - spec/fixtures/facebook_data.yml
 - spec/fixtures/mock_facebook_responses.yml
 - spec/spec_helper.rb
@@ -139,7 +143,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -4094332028190876979
+      hash: 1796660115517042142
       segments: 
       - 0
       version: "0"
@@ -171,6 +175,7 @@ test_files:
 - spec/cases/test_users_spec.rb
 - spec/cases/uploadable_io_spec.rb
 - spec/fixtures/beach.jpg
+- spec/fixtures/cat.m4v
 - spec/fixtures/facebook_data.yml
 - spec/fixtures/mock_facebook_responses.yml
 - spec/spec_helper.rb

data/lib/koala/graph_api_batch.rb

@@ -1,151 +0,0 @@
-module Koala
-  module Facebook
-    class BatchOperation
-      attr_reader :access_token, :http_options, :post_processing, :files
-       
-      def initialize(options = {})
-        @args = (options[:args] || {}).dup # because we modify it below
-        @access_token = options[:access_token]
-        @http_options = (options[:http_options] || {}).dup # dup because we modify it below
-        @batch_args = @http_options.delete(:batch_args) || {}
-        @url = options[:url]
-        @method = options[:method].to_sym
-        @post_processing = options[:post_processing]
-        
-        process_binary_args
-        
-        raise Koala::KoalaError, "Batch operations require an access token, none provided." unless @access_token
-      end
-      
-      def to_batch_params(main_access_token)
-        # set up the arguments
-        args_string = Koala.http_service.encode_params(@access_token == main_access_token ? @args : @args.merge(:access_token => @access_token))
-        
-        response = {
-          :method => @method, 
-          :relative_url => @url,
-        }
-         
-        # handle batch-level arguments, such as name, depends_on, and attached_files
-        @batch_args[:attached_files] = @files.keys.join(",") if @files
-        response.merge!(@batch_args) if @batch_args
-        
-        # for get and delete, we append args to the URL string
-        # otherwise, they go in the body
-        if args_string.length > 0
-          if args_in_url?
-            response[:relative_url] += (@url =~ /\?/ ? "&" : "?") + args_string if args_string.length > 0
-          else
-            response[:body] = args_string if args_string.length > 0
-          end
-        end
-        
-        response
-      end
-  
-      protected
-      
-      def process_binary_args
-        # collect binary files
-        @args.each_pair do |key, value| 
-          if UploadableIO.binary_content?(value)
-            @files ||= {}
-            # we use object_id to ensure unique file identifiers across multiple batch operations
-            # remove it from the original hash and add it to the file store
-            id = "file#{GraphAPI.batch_calls.length}_#{@files.keys.length}"
-            @files[id] = @args.delete(key).is_a?(UploadableIO) ? value : UploadableIO.new(value)
-          end
-        end          
-      end
-      
-      def args_in_url?
-        @method == :get || @method == :delete 
-      end   
-    end
-    
-    module GraphAPIBatchMethods
-      def self.included(base)
-        base.class_eval do
-          # batch mode flags
-          def self.batch_mode?
-            !!@batch_mode
-          end
-
-          def self.batch_calls
-            raise KoalaError, "GraphAPI.batch_calls accessed when not in batch block!" unless batch_mode?
-            @batch_calls
-          end
-
-          def self.batch(http_options = {}, &block)
-            @batch_mode = true
-            @batch_http_options = http_options
-            @batch_calls = []
-            yield
-            begin
-              results = batch_api(@batch_calls)
-            ensure
-              @batch_mode = false
-            end
-            results
-          end
-
-          def self.batch_api(batch_calls)
-            return [] unless batch_calls.length > 0
-            # Facebook requires a top-level access token
-
-            # Get the access token for the user and start building a hash to store params
-            # Turn the call args collected into what facebook expects
-            args = {}
-            access_token = args["access_token"] = batch_calls.first.access_token
-            args['batch'] = batch_calls.map { |batch_op| 
-              args.merge!(batch_op.files) if batch_op.files
-              batch_op.to_batch_params(access_token)
-            }.to_json
-            
-            # Make the POST request for the batch call
-            # batch operations have to go over SSL, but since there's an access token, that secures that
-            result = Koala.make_request('/', args, 'post', @batch_http_options) 
-            # Raise an error if we get a 500
-            raise APIError.new("type" => "HTTP #{result.status.to_s}", "message" => "Response body: #{result.body}") if result.status >= 500
-
-            response = JSON.parse(result.body.to_s)
-            # raise an error if we get a Batch API error message
-            raise APIError.new("type" => "Error #{response["error"]}", "message" => response["error_description"]) if response.is_a?(Hash) && response["error"]
-
-            # otherwise, 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 = JSON.parse("[#{call_result['body'].to_s}]")[0]
-                unless call_result["code"].to_i >= 500 || error = GraphAPI.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
-end