facebooker 1.0.31 → 1.0.41

data/lib/facebooker/session.rb

@@ -72,6 +72,7 @@ module Facebooker
 
     attr_writer :auth_token
     attr_reader :session_key
+    attr_reader :secret_from_session
 
     def self.create(api_key=nil, secret_key=nil)
       api_key ||= self.api_key
@@ -181,10 +182,14 @@ module Facebooker
       !@session_key.nil? && !expired?
     end
 
-    def secure!
-      response = post 'facebook.auth.getSession', :auth_token => auth_token
+    def secure!(args = {})
+      response = post 'facebook.auth.getSession', :auth_token => auth_token, :generate_session_secret => args[:generate_session_secret] ? "1" : "0"
       secure_with!(response['session_key'], response['uid'], response['expires'], response['secret'])
     end    
+    
+    def secure_with_session_secret!
+      self.secure!(:generate_session_secret => true)
+    end
 
     def secure_with!(session_key, uid = nil, expires = nil, secret_from_session = nil)
       @session_key = session_key
@@ -193,30 +198,55 @@ module Facebooker
       @secret_from_session = secret_from_session
     end
 
+    def fql_build_object(type, hash)
+      case type
+      when 'user'
+        user = User.new
+        user.session = self
+        user.populate_from_hash!(hash)
+        user
+      when 'photo'
+        Photo.from_hash(hash)
+      when 'page'
+        Page.from_hash(hash)
+      when 'page_admin'
+        Page.from_hash(hash)
+      when 'group'
+        Group.from_hash(hash)
+      when 'event_member'
+        Event::Attendance.from_hash(hash)
+      else
+        hash
+      end
+    end
+
     def fql_query(query, format = 'XML')
       post('facebook.fql.query', :query => query, :format => format) do |response|
         type = response.shift
         return [] if type.nil?
         response.shift.map do |hash|
-          case type
-          when 'user'
-            user = User.new
-            user.session = self
-            user.populate_from_hash!(hash)
-            user
-          when 'photo'
-            Photo.from_hash(hash)
-          when 'page'
-            Page.from_hash(hash)
-          when 'page_admin'
-            Page.from_hash(hash)
-          when 'event_member'
-            Event::Attendance.from_hash(hash)
-          else
-            hash
+          fql_build_object(type, hash)
+        end
+      end
+    end
+
+    def fql_multiquery(queries, format = 'XML')
+      results = {}
+      post('facebook.fql.multiquery', :queries => queries.to_json, :format => format) do |responses|
+        responses.each do |response|
+          name = response.shift
+          response = response.shift
+          type = response.shift
+          value = [] 
+          unless type.nil?
+            value = response.shift.map do |hash|
+              fql_build_object(type, hash)
+            end
           end
+          results[name] = value
         end
       end
+      results
     end
 
     def user
@@ -270,9 +300,11 @@ module Facebooker
 
     # Takes page_id and uid, returns true if uid is a fan of the page_id
     def is_fan(page_id, uid)
-      post('facebook.pages.isFan', :page_id=>page_id, :uid=>uid)
+      puts "Deprecated. Use Page#user_is_fan? instead"
+      Page.new(page_id).user_is_fan?(uid)
     end    
 
+
     #
     # Returns a proxy object for handling calls to Facebook cached items
     # such as images and FBML ref handles
@@ -388,10 +420,10 @@ module Facebooker
 
     ##
     # Send email to as many as 100 users at a time
-    def send_email(user_ids, subject, text, fbml = nil) 			
+    def send_email(user_ids, subject, text, fbml = nil)       
       user_ids = Array(user_ids)
       params = {:fbml => fbml, :recipients => user_ids.map{ |id| User.cast_to_facebook_id(id)}.join(','), :text => text, :subject => subject} 
-      post 'facebook.notifications.sendEmail', params
+      post 'facebook.notifications.sendEmail', params, false
     end
 
     # Only serialize the bare minimum to recreate the session.
@@ -589,7 +621,9 @@ module Facebooker
 
       def signature_for(params)
         raw_string = params.inject([]) do |collection, pair|
-          collection << pair.join("=")
+          collection << pair.map { |x|
+            Array === x ? Facebooker.json_encode(x) : x
+          }.join("=")
           collection
         end.sort.join
         Digest::MD5.hexdigest([raw_string, secret_for_method(params[:method])].join)

data/lib/facebooker/version.rb

@@ -2,7 +2,7 @@ module Facebooker #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 0
-    TINY  = 31
+    TINY  = 41
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/rack/facebook.rb

@@ -24,29 +24,41 @@ module Rack
   #   end
   #
   class Facebook
-    def initialize(app, secret_key, &condition)
+    def initialize(app, &condition)
       @app = app
-      @secret_key = secret_key
       @condition = condition
     end
     
     def call(env)
-      if @condition.nil? || @condition.call(env)
-        request = Rack::Request.new(env)
-        fb_params = extract_fb_sig_params(request.POST)
-        unless fb_params.empty?
-          unless signature_is_valid?(fb_params, request.POST['fb_sig'])
-            return Rack::Response.new(["Invalid Facebook signature"], 400).finish
-          end
-          env['REQUEST_METHOD'] = fb_params["request_method"] if fb_params["request_method"]
-          convert_parameters!(request.POST)
+      return @app.call(env) unless @condition.nil? || @condition.call(env)
+
+      request = Rack::Request.new(env)
+      fb_sig, fb_params = nil, nil
+
+      [ request.POST, request.GET ].each do |params|
+        fb_sig, fb_params = fb_sig_and_params( params )
+        break if fb_sig
+      end
+
+      return @app.call(env) if fb_params.empty?
+
+      Facebooker.with_application(fb_params['api_key']) do
+        unless signature_is_valid?(fb_params, fb_sig)
+          return Rack::Response.new(["Invalid Facebook signature"], 400).finish
         end
+        env['REQUEST_METHOD'] = fb_params["request_method"] if fb_params["request_method"]
+        convert_parameters!(request.params)
+        @app.call(env)
       end
-      @app.call(env)
     end
     
     private
 
+    def fb_sig_and_params( params )
+      return nil, [] unless params['fb_sig']
+      return params['fb_sig'], extract_fb_sig_params(params)
+    end
+
     def extract_fb_sig_params(params)
       params.inject({}) do |collection, (param, value)|
         collection[param.sub(/^fb_sig_/, '')] = value if param[0,7] == 'fb_sig_'
@@ -56,7 +68,7 @@ module Rack
     
     def signature_is_valid?(fb_params, actual_sig)
       raw_string = fb_params.map{ |*args| args.join('=') }.sort.join
-      expected_signature = Digest::MD5.hexdigest([raw_string, @secret_key].join)
+      expected_signature = Digest::MD5.hexdigest([raw_string, Facebooker.secret_key].join)
       actual_sig == expected_signature
     end
     
@@ -74,4 +86,4 @@ module Rack
       end
     end
   end
-end
+end

data/lib/tasks/tunnel.rake

@@ -28,7 +28,7 @@ namespace :facebooker do
 
     task :config => :environment do
      facebook_config = File.dirname(__FILE__) + '/../../../../../config/facebooker.yml'
-     FACEBOOKER = YAML.load_file(facebook_config)[RAILS_ENV]
+     FACEBOOKER = YAML.load(ERB.new(File.read(facebook_config)).result)[RAILS_ENV]
      @public_host_username = FACEBOOKER['tunnel']['public_host_username'] 
      @public_host = FACEBOOKER['tunnel']['public_host'] 
      @public_port = FACEBOOKER['tunnel']['public_port'] 

data/test/facebooker/adapters_test.rb

@@ -93,4 +93,82 @@ class Facebooker::AdaptersTest < Test::Unit::TestCase
   def test_bebo_process_data
 
   end
+
+  def test_fetch_config_for_can_find_top_level_api_key
+    old = Facebooker.instance_variable_get('@raw_facebooker_configuration')
+    # Now that we've backed up the old value...
+    raw_fb_config = { 'api_key' => 'a key' }
+    Facebooker.instance_variable_set('@raw_facebooker_configuration', raw_fb_config)
+    assert_equal Facebooker.fetch_config_for( 'a key' ), raw_fb_config
+  ensure
+    # Put the old value back
+    Facebooker.instance_variable_set('@raw_facebooker_configuration', old)
+  end
+
+  def test_fetch_config_for_can_find_deep_api_key
+    old = Facebooker.instance_variable_get('@raw_facebooker_configuration')
+    # Now that we've backed up the old value...
+    raw_fb_config = { 'api_key' => 'a key',
+                      'alternative_keys' => {
+                        'another key'     => { 'secret_key' => 'sdfsd' },
+                        'yet another key' => { 'secret_key' => '9ho2h' } } }
+    Facebooker.instance_variable_set('@raw_facebooker_configuration', raw_fb_config)
+    assert_equal raw_fb_config['alternative_keys']['another key'].merge( 'api_key' => 'another key' ),
+                 Facebooker.fetch_config_for( 'another key' )
+  ensure
+    # Put the old value back
+    Facebooker.instance_variable_set('@raw_facebooker_configuration', old)
+  end
+
+  def test_fetch_config_for_returns_false_if_no_apikey_found
+    old = Facebooker.instance_variable_get('@raw_facebooker_configuration')
+    # Now that we've backed up the old value...
+    raw_fb_config = { 'api_key' => 'a key' }
+    Facebooker.instance_variable_set('@raw_facebooker_configuration', raw_fb_config)
+    assert ! Facebooker.fetch_config_for( 'another key' )
+  ensure
+    # Put the old value back
+    Facebooker.instance_variable_set('@raw_facebooker_configuration', old)
+  end
+
+  def test_with_application_yields_if_no_config_is_found
+    flexmock( Facebooker ).
+      should_receive( :fetch_config_for ).
+      and_return( false )
+    # Is there a better way to assert the block is yielded?
+    @changes_to_true = false
+    Facebooker.with_application('somekey not found') do
+      @changes_to_true = true
+    end
+    assert @changes_to_true
+  end
+
+  def test_with_application_changes_config_inside_block
+    flexmock( Facebooker ).
+      should_receive( :fetch_config_for ).
+      and_return({ 'api_key'    => 'a key',
+                   'secret_key' => 'my secret key' })
+    Facebooker.with_application('a key') do
+      @secret_in_block = Facebooker.secret_key
+    end
+    # Check outside the block, assures the assertion gets run
+    assert_equal 'my secret key', @secret_in_block
+  end
+
+  def test_with_application_restores_last_config_outside_block
+    flexmock( Facebooker ).
+      should_receive( :fetch_config_for ).
+      and_return( { 'api_key'    => 'a key',
+                    'secret_key' => 'my secret key' },
+                  { 'api_key'    => 'another key',
+                    'secret_key' => 'my other secret key' } )
+    Facebooker.with_application('a key') do
+      Facebooker.with_application('another key') do
+      end
+      @secret_in_outer_block = Facebooker.secret_key
+    end
+    # Check outside the block, assures the assertion gets run
+    assert_equal 'my secret key', @secret_in_outer_block
+  end
+
 end

data/test/facebooker/data_test.rb

@@ -6,46 +6,46 @@ class Facebooker::DataTest < Test::Unit::TestCase
     #make sure we use net::http since that's what the tests expect
     Facebooker.use_curl=false
   end
-  
+
   def test_can_ask_facebook_to_set_a_cookies
     expect_http_posts_with_responses(example_set_cookie_xml)
     assert(@session.data.set_cookie(12345, 'name', 'value'))
   end
-    
+
   def test_can_ask_facebook_to_get_cookies
     expect_http_posts_with_responses(example_get_cookies_xml)
     assert(@session.data.get_cookies(12345))
   end
-  
+
   def test_can_get_cookies_for_user
     mock_http = establish_session
     mock_http.should_receive(:post_form).and_return(example_get_cookies_xml).once.ordered(:posts)
-    cookies = @session.data.get_cookies(508508326)    
+    cookies = @session.data.get_cookies(508508326)
     assert_equal 'Foo', cookies.first.name
     assert_equal 'Bar', cookies.first.value
   end
-  
+
   def test_can_ask_facebook_to_set_a_preference
     expect_http_posts_with_responses(example_set_preference_xml)
     assert(@session.data.set_preference(0, 'hello'))
   end
-    
+
   def test_can_ask_facebook_to_get_preference
     expect_http_posts_with_responses(example_get_preference_xml)
     assert(@session.data.get_preference(0))
   end
-  
+
   def test_can_get_preference
     mock_http = establish_session
     mock_http.should_receive(:post_form).and_return(example_get_preference_xml).once.ordered(:posts)
-    assert_equal 'hello', @session.data.get_preference(0) 
+    assert_equal 'hello', @session.data.get_preference(0)
   end
 
   private
   def example_set_cookie_xml
     <<-XML
     <?xml version="1.0" encoding="UTF-8"?>
-    <data_setCookie_response xmlns="http://api.facebook.com/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+    <data_setCookie_response xmlns="http://api.facebook.com/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://api.facebook.com/1.0/ http://api.facebook.com/1.0/facebook.xsd">1</data_setCookie_response>
     XML
   end
@@ -53,7 +53,7 @@ class Facebooker::DataTest < Test::Unit::TestCase
   def example_get_cookies_xml
     <<-XML
     <?xml version="1.0" encoding="UTF-8"?>
-    <data_getCookie_response xmlns="http://api.facebook.com/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+    <data_getCookie_response xmlns="http://api.facebook.com/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://api.facebook.com/1.0/ http://api.facebook.com/1.0/facebook.xsd">
       <cookies>
         <uid>508508326</uid>
@@ -65,11 +65,11 @@ class Facebooker::DataTest < Test::Unit::TestCase
     </data_getCookie_response>
     XML
   end
-  
+
   def example_set_preference_xml
     <<-XML
     <?xml version="1.0" encoding="UTF-8"?>
-    <data_setUserPreference_response xmlns="http://api.facebook.com/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+    <data_setUserPreference_response xmlns="http://api.facebook.com/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://api.facebook.com/1.0/ http://api.facebook.com/1.0/facebook.xsd"/>
     XML
   end
@@ -77,10 +77,10 @@ class Facebooker::DataTest < Test::Unit::TestCase
   def example_get_preference_xml
     <<-XML
     <?xml version="1.0" encoding="UTF-8"?>
-    <data_getUserPreference_response xmlns="http://api.facebook.com/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+    <data_getUserPreference_response xmlns="http://api.facebook.com/1.0/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://api.facebook.com/1.0/ http://api.facebook.com/1.0/facebook.xsd">
       hello
     </data_getUserPreference_response>
     XML
   end
-end
+end

data/test/facebooker/models/page_test.rb

@@ -0,0 +1,46 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'active_support'
+
+class Facebooker::PageTest < Test::Unit::TestCase
+
+  def test_should_be_able_to_populate_with_photo_id_as_integer
+    p = Facebooker::Page.new(12345)
+    assert_equal(12345,p.page_id)
+  end
+  
+  def test_should_be_ble_to_initialize_with_photo_id_as_string
+    p = Facebooker::Page.new("12345")
+    assert_equal("12345",p.page_id)    
+  end
+  
+  def test_should_be_able_to_initialize_with_hash
+    p = Facebooker::Page.new(:page_id=>12345,:name=>"test page")
+    assert_equal("test page",p.name)
+    assert_equal(12345,p.page_id)
+  end
+  
+  def test_should_be_able_to_see_if_user_is_fan_with_id
+    Facebooker::Session.current.expects(:post).with("facebook.pages.isFan",:page_id=>12345,:uid=>12451752).returns(true)
+    p = Facebooker::Page.new(12345)
+    assert p.user_is_fan?(12451752)
+  end
+  
+  def test_should_be_able_to_see_if_user_is_fan_with_user
+    Facebooker::Session.current.expects(:post).with("facebook.pages.isFan",:page_id=>12345,:uid=>12451752).returns(false)
+    p = Facebooker::Page.new(12345)
+    assert !p.user_is_fan?(Facebooker::User.new(12451752))
+  end
+  
+  def test_should_be_able_to_see_if_user_is_admin_with_id
+    Facebooker::Session.current.expects(:post).with("facebook.pages.isAdmin",:page_id=>12345,:uid=>12451752).returns(false)
+    p = Facebooker::Page.new(12345)
+    assert !p.user_is_admin?(12451752)
+    
+  end
+  
+  def test_should_be_able_to_see_if_user_is_admin_with_user
+    Facebooker::Session.current.expects(:post).with("facebook.pages.isAdmin",:page_id=>12345,:uid=>12451752).returns(true)
+    p = Facebooker::Page.new(12345)
+    assert p.user_is_admin?(Facebooker::User.new(12451752))
+  end
+end

data/test/facebooker/models/photo_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'active_support'
+
+class Facebooker::UserTest < Test::Unit::TestCase
+
+  def test_pid_should_be_treated_as_a_string
+    @photo = Facebooker::Photo.new(:pid=>"100000025509592_6801")
+    assert_equal("100000025509592_6801",@photo.pid)
+  end
+  
+  def test_setting_id_should_also_use_new_method
+    @photo = Facebooker::Photo.new(:id=>"100000025509592_6801")
+    assert_equal("100000025509592_6801",@photo.id)
+  end
+
+end