koala 1.1.0 → 1.2.0

data/lib/koala/version.rb

@@ -0,0 +1,3 @@
+module Koala
+  VERSION = "1.2.0"
+end

data/lib/koala.rb

@@ -8,8 +8,6 @@ require 'openssl'
 require 'base64'
 
 # include koala modules
-require 'koala/http_services'
-require 'koala/http_services/net_http_service'
 require 'koala/oauth'
 require 'koala/graph_api'
 require 'koala/graph_batch_api'
@@ -18,11 +16,17 @@ require 'koala/graph_collection'
 require 'koala/rest_api'
 require 'koala/realtime_updates'
 require 'koala/test_users'
-require 'koala/http_services'
+
+# HTTP module so we can communicate with Facebook
+require 'koala/http_service'
 
 # add KoalaIO class
 require 'koala/uploadable_io'
 
+# miscellaneous
+require 'koala/utils'
+require 'koala/version'
+
 module Koala
 
   module Facebook
@@ -31,6 +35,7 @@ module Koala
     # Contributors: Alex Koppel, Chris Baclig, Rafi Jacoby, and the team at Context Optional
     # http://github.com/arsduo/koala
 
+    # APIs
     class API
       # initialize with an access token
       def initialize(access_token = nil)
@@ -38,10 +43,13 @@ module Koala
       end
       attr_reader :access_token
 
+      include GraphAPIMethods
+      include RestAPIMethods
+
       def api(path, args = {}, verb = "get", options = {}, &error_checking_block)
         # Fetches the given path in the Graph API.
         args["access_token"] = @access_token || @app_access_token if @access_token || @app_access_token
-        
+
         # add a leading /
         path = "/#{path}" unless path =~ /^\//
 
@@ -64,35 +72,30 @@ module Koala
       end
     end
 
-    # APIs
-    
-    class GraphAPI < API
-      include GraphAPIMethods
-    end
-    
-    class GraphBatchAPI < GraphAPI
-      include GraphBatchAPIMethods      
-    end
-        
-    class RestAPI < API
-      include RestAPIMethods
+    # special enhanced APIs
+    class GraphBatchAPI < API
+      include GraphBatchAPIMethods
     end
 
-    class GraphAndRestAPI < API
-      include GraphAPIMethods
-      include RestAPIMethods
-    end
-
-    class RealtimeUpdates < API
+    class RealtimeUpdates
       include RealtimeUpdateMethods
     end
 
-    class TestUsers < API
+    class TestUsers
       include TestUserMethods
-      # make the Graph API accessible in case someone wants to make other calls to interact with their users
-      attr_reader :graph_api
     end
 
+    # legacy support for old APIs
+    class OldAPI < API;
+      def initialize(*args)
+        Koala::Utils.deprecate("#{self.class.name} is deprecated and will be removed in a future version; please use the API class instead.")
+        super
+      end
+    end
+    class GraphAPI < OldAPI; end
+    class RestAPI < OldAPI; end
+    class GraphAndRestAPI < OldAPI; end
+
     # Errors
 
     class APIError < StandardError
@@ -106,29 +109,28 @@ module Koala
 
   class KoalaError < StandardError; end
 
-  # Make an api request using the provided api service or one passed by the caller
-  def self.make_request(path, args, verb, options = {})
-    http_service = options.delete(:http_service) || Koala.http_service
-    options = options.merge(:use_ssl => true) if @always_use_ssl
-    http_service.make_request(path, args, verb, options)
-  end
 
-  # finally, set up the http service Koala methods used to make requests
-  # you can use your own (for HTTParty, etc.) by calling Koala.http_service = YourModule
+  # finally, the few things defined on the Koala module itself
   class << self
     attr_accessor :http_service
-    attr_accessor :always_use_ssl
-    attr_accessor :base_http_service
   end
-  Koala.base_http_service = NetHTTPService
-
-  # by default, try requiring Typhoeus -- if that works, use it
-  # if you have Typheous and don't want to use it (or want another service),
-  # you can run Koala.http_service = NetHTTPService (or MyHTTPService)
-  begin
-    require 'koala/http_services/typhoeus_service'
-    Koala.http_service = TyphoeusService
-  rescue LoadError
-    Koala.http_service = Koala.base_http_service
+
+  def self.http_service=(service)
+    if service.respond_to?(:deprecated_interface)
+      # if this is a deprecated module, support the old interface
+      # by changing the default adapter so the right library is used
+      # we continue to use the single HTTPService module for everything
+      service.deprecated_interface 
+    else
+      # if it's a real http_service, use it
+      @http_service = service
+    end
   end
+
+  def self.make_request(path, args, verb, options = {})
+    http_service.make_request(path, args, verb, options)
+  end
+
+  # we use Faraday as our main service, with mock as the other main one
+  self.http_service = HTTPService
 end

data/readme.md

@@ -1,77 +1,95 @@
+[![Build Status](https://secure.travis-ci.org/arsduo/koala.png)](http://travis-ci.org/arsduo/koala)
+
 Koala
 ====
-[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:
+[Koala](http://github.com/arsduo/koala) is a 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 libraries, providing API accessors and returning simple JSON.
+* Fast: Koala should, out of the box, be quick. Out of the box, we use Facebook's faster read-only servers when possible and if available, the Typhoeus gem to make snappy Facebook requests.  Of course, that brings us to our next topic:
+* Flexible: Koala should be useful to everyone, regardless of their current configuration.  (We support JRuby, Rubinius, and REE as well as vanilla Ruby, and use the Faraday library to provide complete flexibility over how HTTP requests are made.)
+* Tested: Koala should have complete test coverage, so you can rely on it.  (Our test coverage is complete and can be run against either mocked responses or the live Facebook servers.)
+
+Facebook Changes on October 1, 2011
+---
 
-* 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.  (In addition to vanilla Ruby, we support JRuby, Rubinius, and REE, and provide  built-in mechanism for using whichever HTTP library you prefer.)
-* 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.)
+**Koala 1.2 supports all of Facebook's new authentication schemes**, which will be introduced on October 1, 2011; the old Javascript library and older authentication schemes will be deprecated at the same time. 
+
+To test your application, upgrade to the latest version of Koala (see below) and configure your application according to Facebook's [OAuth 2.0 and HTTPS Migration](https://developers.facebook.com/docs/oauth2-https-migration/) guide.  If you have the appropriate calls to get_user_info_from_cookies (apps using the Javascript SDK) and/or parse_signed_params (for Canvas and tab apps), your application should work without a hitch.
+
+_Note_: in their new secure cookie format, Facebook provides an OAuth code, which Koala automatically exchanges for an access token.  Because this involves a call to Facebook's servers, you should consider storing the user's access token in their session and only calling get_user_info_from_cookies when necessary (access_token not present, you discover it's expired, etc.).  Otherwise, you'll be calling out to Facebook each time the user loads a page, slowing down your site.  (As we figure out best practices for this, we'll update the wiki.)
 
 Installation
 ---
 
 Easy:
-    
+
     [sudo|rvm] gem install koala
-    
+
 Or in Bundler:
-  
+
     gem "koala"
-  
+
 Graph API
 ----
 The Graph API is the simple, slick new interface to Facebook's data.  Using it with Koala is quite straightforward:
-
-    @graph = Koala::Facebook::GraphAPI.new(oauth_access_token)
+  
+    @graph = Koala::Facebook::API.new(oauth_access_token)
+    # in 1.1 or earlier, use GraphAPI instead of API
+    
     profile = @graph.get_object("me")
     friends = @graph.get_connections("me", "friends")
     @graph.put_object("me", "feed", :message => "I am writing on my wall!")
 
+    # you can even use the new Timeline API
+    # see https://developers.facebook.com/docs/beta/opengraph/tutorial/
+    @graph.put_connections("me", "namespace:action", :object => object_url)
+
 The response of most requests is the JSON data returned from the Facebook servers as a Hash.
 
-When retrieving data that returns an array of results (for example, when calling GraphAPI#get_connections or GraphAPI#search) a GraphCollection object (a sub-class of Array) will be returned, which contains added methods for getting the next and previous page of results:
+When retrieving data that returns an array of results (for example, when calling API#get_connections or API#search) a GraphCollection object will be returned, which makes it easy to page through the results:
 
     # Returns the feed items for the currently logged-in user as a GraphCollection
     feed = @graph.get_connections("me", "feed")
-
-    # GraphCollection is a sub-class of Array, so you can use it as a usual Array
-    first_entry = feed[0]
-    last_entry = feed.last
-
-    # Returns the next page of results (also as a GraphCollection)
+    feed.each {|f| do_something_with_item(f) } # it's a subclass of Array
     next_feed = feed.next_page
 
-    # Returns an array describing the URL for the next page: [path, arguments]
-    # This is useful for paging across multiple requests
-    next_path, next_args = feed.next_page_params
+    # You can also get an array describing the URL for the next page: [path, arguments]
+    # This is useful for storing page state across multiple browser requests
+    next_page_params = feed.next_page_params
+    page = @graph.get_page(next_page_params)
 
-    # 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:
+You can also make multiple calls at once using Facebook's batch API:
 
     # Returns an array of results as if they were called non-batch
     @graph.batch do |batch_api|
       batch_api.get_object('me')
-      batch_api.get_object('koppel')
+      batch_api.put_wall_post('Making a post in a batch.')
     end
 
-Check out the wiki for more examples.
+Check out the wiki for more details and examples.
 
 The REST API
 -----
 Where the Graph API and the old REST API overlap, you should choose the Graph API.  Unfortunately, that overlap is far from complete, and there are many important API calls that can't yet be done via the Graph.
 
-Koala now supports the old-school REST API using OAuth access tokens; to use this, instantiate your class using the RestAPI class:
+Fortunately, Koala supports the REST API using the very same interface; to use this, instantiate an API:
 
-  	@rest = Koala::Facebook::RestAPI.new(oauth_access_token)
+    @rest = Koala::Facebook::API.new(oauth_access_token)
+    # in 1.1 or earlier, use RestAPI instead of API
+  	
   	@rest.fql_query(my_fql_query) # convenience method
   	@rest.fql_multiquery(fql_query_hash) # convenience method
   	@rest.rest_call("stream.publish", arguments_hash) # generic version
 
-We reserve the right to expand the built-in REST API coverage to additional convenience methods in the future, depending on how fast Facebook moves to fill in the gaps.
+Of course, you can use the Graph API methods on the same object -- the power of two APIs right in the palm of your hand.
 
-(If you want the power of both APIs in the palm of your hand, try out the GraphAndRestAPI class.)
+    @api = Koala::Facebook::API.new(oauth_access_token)
+    # in 1.1 or earlier, use GraphAndRestAPI instead of API
+    
+    @api = Koala::Facebook::API.new(oauth_access_token)
+    fql = @api.fql_query(my_fql_query)
+    @api.put_wall_post(process_result(fql))
+    
 
 OAuth
 -----
@@ -92,7 +110,7 @@ You can also get your application's own access token, which can be used without
     @oauth.get_app_access_token
 
 For those building apps on Facebook, parsing signed requests is simple:
-    @oauth.parse_signed_request(request)
+    @oauth.parse_signed_request(signed_request_string)
 
 Or, if for some horrible reason, you're still using session keys, despair not!  It's easy to turn them into shiny, modern OAuth tokens:
     @oauth.get_token_from_session_key(session_key)
@@ -130,10 +148,10 @@ Test Users
 -----
 
 We also support the test users API, allowing you to conjure up fake users and command them to do your bidding using the Graph or REST API:
-    
+
     @test_users = Koala::Facebook::TestUsers.new(:app_id => id, :secret => secret)
     user = @test_users.create(is_app_installed, desired_permissions)
-    user_graph_api = Koala::Facebook::GraphAPI.new(user["access_token"])
+    user_graph_api = Koala::Facebook::API.new(user["access_token"])
     # or, if you want to make a whole community:
     @test_users.create_network(network_size, is_app_installed, common_permissions)
 
@@ -149,14 +167,16 @@ 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:
     bundle exec rake spec
-    
+
 
 You can also run live tests against Facebook's servers:
-    
+
     # Again from anywhere in the project directory:
     LIVE=true bundle exec rake spec
+    # you can also test against Facebook's beta tier
+    LIVE=true BETA=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 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.)
+By default, the live tests are run against test users, so you can run them as frequently as you want.  If you want to run them against a real user, however, you can fill in the OAuth token, code, and access\_token values in spec/fixtures/facebook_data.yml.  See the wiki for more details.

data/spec/cases/{api_base_spec.rb → api_spec.rb}

@@ -44,7 +44,7 @@ describe "Koala::Facebook::API" do
 
     Koala.stub(:make_request).and_return(response)
 
-    @service.api('anything', 'get', {}, :http_component => http_component)
+    @service.api('anything', {}, 'get', :http_component => http_component)
   end
 
   it "should return the body of the request as JSON if no http_component is given" do
@@ -98,4 +98,29 @@ describe "Koala::Facebook::API" do
     end
   end
 
-end
+  describe "with an access token" do
+    before(:each) do
+      @api = Koala::Facebook::API.new(@token)
+    end
+
+    it_should_behave_like "Koala RestAPI"
+    it_should_behave_like "Koala RestAPI with an access token"
+
+    it_should_behave_like "Koala GraphAPI"
+    it_should_behave_like "Koala GraphAPI with an access token"
+    it_should_behave_like "Koala GraphAPI with GraphCollection"
+  end
+
+  describe "without an access token" do
+    before(:each) do
+      @api = Koala::Facebook::API.new
+    end
+
+    it_should_behave_like "Koala RestAPI"
+    it_should_behave_like "Koala RestAPI without an access token"
+
+    it_should_behave_like "Koala GraphAPI"
+    it_should_behave_like "Koala GraphAPI without an access token"
+    it_should_behave_like "Koala GraphAPI with GraphCollection"
+  end
+end

data/spec/cases/error_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Koala::Facebook::APIError do
+  it "is a StandardError" do
+    Koala::Facebook::APIError.new.should be_a(StandardError)
+  end
+
+  it "has an accessor for fb_error_type" do
+    Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:fb_error_type)
+    Koala::Facebook::APIError.instance_methods.map(&:to_sym).should include(:fb_error_type=)
+  end
+
+  it "sets fb_error_type to details['type']" do
+    type = "foo"
+    Koala::Facebook::APIError.new("type" => type).fb_error_type.should == type
+  end
+
+  it "sets the error message details['type']: details['message']" do
+    type = "foo"
+    message = "bar"
+    error = Koala::Facebook::APIError.new("type" => type, "message" => message)
+    error.message.should =~ /#{type}/
+    error.message.should =~ /#{message}/
+  end
+end
+
+describe Koala::KoalaError do
+  it "is a StandardError" do
+     Koala::KoalaError.new.should be_a(StandardError)
+  end
+end
+

data/spec/cases/graph_and_rest_api_spec.rb

@@ -1,31 +1,22 @@
 require 'spec_helper'
 
 describe "Koala::Facebook::GraphAndRestAPI" do
-  include LiveTestingDataHelper
-
-  describe "with an access token" do
-    before(:each) do
-      @api = Koala::Facebook::GraphAndRestAPI.new(@token)
+  describe "class consolidation" do
+    before :each do
+      Koala::Utils.stub(:deprecate) # avoid actual messages to stderr
     end
 
-    it_should_behave_like "Koala RestAPI"
-    it_should_behave_like "Koala RestAPI with an access token"
-
-    it_should_behave_like "Koala GraphAPI"
-    it_should_behave_like "Koala GraphAPI with an access token"
-    it_should_behave_like "Koala GraphAPI with GraphCollection"
-  end
-
-  describe "without an access token" do
-    before(:each) do
-      @api = Koala::Facebook::GraphAndRestAPI.new
+    it "still allows you to instantiate a GraphAndRestAPI object" do
+      api = Koala::Facebook::GraphAndRestAPI.new("token").should be_a(Koala::Facebook::GraphAndRestAPI)
     end
 
-    it_should_behave_like "Koala RestAPI"
-    it_should_behave_like "Koala RestAPI without an access token"
+    it "ultimately creates an API object" do
+      api = Koala::Facebook::GraphAndRestAPI.new("token").should be_a(Koala::Facebook::API)
+    end
 
-    it_should_behave_like "Koala GraphAPI"
-    it_should_behave_like "Koala GraphAPI without an access token"
-    it_should_behave_like "Koala GraphAPI with GraphCollection"
+    it "fires a depreciation warning" do
+      Koala::Utils.should_receive(:deprecate)
+      api = Koala::Facebook::GraphAndRestAPI.new("token")
+    end
   end
 end