rfacebook 0.9.1 → 0.9.2

data/lib/facebook_web_session.rb

@@ -31,30 +31,19 @@ require "facebook_session"
 
 module RFacebook
 
-class FacebookWebSession < FacebookSession
-  
-    # SECTION: Properties
+  class FacebookWebSession < FacebookSession
     
-    def session_key
-      return @session_key
-    end
-  
-    def session_user_id
-      return @session_uid
-    end
-  
-    def session_expires
-      return @session_expires
-    end
-    
-    # SECTION: URL Getters
+    ################################################################################################
+    ################################################################################################
+    # :section: URL Accessors
+    ################################################################################################
     
     # Function: get_login_url
     #   Gets the authentication URL
     #
     # Parameters:
     #   options.next          - the page to redirect to after login
-    #   options.popup         - boolean, whether or not to use the popup style (defaults to true)
+    #   options.popup         - boolean, whether or not to use the popup style (defaults to false)
     #   options.skipcookie    - boolean, whether to force new Facebook login (defaults to false)
     #   options.hidecheckbox  - boolean, whether to show the "infinite session" option checkbox
     def get_login_url(options={})
@@ -80,6 +69,11 @@ class FacebookWebSession < FacebookSession
     
     end
     
+    # Function: get_install_url
+    #   Gets the installation URL for this application
+    #
+    # Parameters:
+    #   options.next          - the page to redirect to after installation
     def get_install_url(options={})
     
       # handle options
@@ -93,44 +87,10 @@ class FacebookWebSession < FacebookSession
     
     end
   
-
-    # SECTION: Callback Verification Helpers
-    
-    def get_fb_sig_params(originalParams)
-            
-      # setup
-      timeout = 48*3600
-      namespace = "fb_sig"
-      prefix = "#{namespace}_"
-      
-      # get the params prefixed by "fb_sig_" (and remove the prefix)
-      sigParams = {}
-      originalParams.each do |k,v|
-        oldLen = k.length
-        newK = k.sub(prefix, "")
-        if oldLen != newK.length
-          sigParams[newK] = v
-        end
-      end
-      
-      # handle invalidation
-      if (timeout and (sigParams["time"].nil? or (Time.now.to_i - sigParams["time"].to_i > timeout.to_i)))
-        # invalidate if the timeout has been reached
-        sigParams = {}
-      end
-      
-      if !sig_params_valid?(sigParams, originalParams[namespace])
-        # invalidate if the signatures don't match
-        sigParams = {}
-      end
-      
-      return sigParams
-      
-    end
-  
-  
-  
-    # SECTION: Session Activation
+    ################################################################################################
+    ################################################################################################
+    # :section: Session Activation
+    ################################################################################################
   
     # Function: activate_with_token
     #   Gets the session information available after current user logs in.
@@ -140,7 +100,7 @@ class FacebookWebSession < FacebookSession
     def activate_with_token(auth_token)
       result = call_method("auth.getSession", {:auth_token => auth_token})
       if result != nil
-        @session_uid = result.at("uid").inner_html
+        @session_user_id = result.at("uid").inner_html
         @session_key = result.at("session_key").inner_html
         @session_expires = result.at("expires").inner_html
       end
@@ -161,42 +121,79 @@ class FacebookWebSession < FacebookSession
     
       # determine the current user's id
       if uid
-        @session_uid = uid
+        @session_user_id = uid
       else
         result = call_method("users.getLoggedInUser")
-        @session_uid = result.at("users_getLoggedInUser_response").inner_html
+        @session_user_id = result.at("users_getLoggedInUser_response").inner_html
       end
       
     end
-  
-    def is_valid?
-      return (is_activated? and !session_expired?)
+    
+    ################################################################################################
+    ################################################################################################
+    # :section: Canvas Signature Validation
+    ################################################################################################
+    
+    # Function: get_fb_sig_params
+    #   Returns the fb_sig params from Hash that has all request params.  Hash is empty if the
+    #   signature was invalid.
+    #
+    # Parameters:
+    #   originalParams - a Hash that contains the fb_sig_* params (i.e. Rails params)
+    #
+    def get_fb_sig_params(originalParams)
+            
+      # setup
+      timeout = 48*3600
+      prefix = "fb_sig_"
+      
+      # get the params prefixed by "fb_sig_" (and remove the prefix)
+      sigParams = {}
+      originalParams.each do |k,v|
+        oldLen = k.length
+        newK = k.sub(prefix, "")
+        if oldLen != newK.length
+          sigParams[newK] = v
+        end
+      end
+      
+      # handle invalidation
+      if (timeout and (sigParams["time"].nil? or (Time.now.to_i - sigParams["time"].to_i > timeout.to_i)))
+        # invalidate if the timeout has been reached
+        @logger.debug "** RFACEBOOK(GEM) - fbparams is empty because the signature was timed out" if @logger
+        sigParams = {}
+      end
+      
+      # check that the signatures match
+      expectedSig = originalParams["fb_sig"]
+      if !(sigParams and expectedSig and generate_signature(sigParams, @api_secret) == expectedSig)
+        # didn't match, empty out the params
+        @logger.debug "** RFACEBOOK(GEM) - fbparams is empty because the signature did not match" if @logger
+        sigParams = {}
+      end
+            
+      return sigParams
+      
     end
   
-  
-  
-  
-  
-  
-    # SECTION: Protected methods
-    protected
-  
+    ################################################################################################
+    ################################################################################################
+    # :section: Template Methods
+    ################################################################################################
+    
+    # Function: is_activated?
+    #   Returns true when we have activated ourselves somehow
     def is_activated?
       return (@session_key != nil)
     end
   
     # Function: get_secret
-    #   Template method, used by super::signature to generate a signature
-    def get_secret(params)
+    #   Used by super::signature to generate a signature
+    #   Web sessions simply use their API secret.
+    def get_secret(params) # :nodoc:
       return @api_secret
     end
-    
-    def sig_params_valid?(sigParams, expectedSig)
-      return (sigParams and expectedSig and generate_signature(sigParams, @api_secret) == expectedSig)
-    end
   
   end
-
-
-
+  
 end

data/lib/rfacebook_on_rails/controller_extensions.rb

@@ -34,15 +34,15 @@ module RFacebook
   module Rails
     module ControllerExtensions
       
-      # SECTION: StandardErrors
+      # :section: StandardErrors
     
-      class APIKeyNeededStandardError < StandardError; end
-      class APISecretNeededStandardError < StandardError; end
-      class APICanvasPathNeededStandardError < StandardError; end
-      class APICallbackNeededStandardError < StandardError; end
-      class APIFinisherNeededStandardError < StandardError; end
+      class APIKeyNeededStandardError < StandardError; end # :nodoc:
+      class APISecretNeededStandardError < StandardError; end # :nodoc:
+      class APICanvasPathNeededStandardError < StandardError; end # :nodoc:
+      class APICallbackNeededStandardError < StandardError; end # :nodoc:
+      class APIFinisherNeededStandardError < StandardError; end # :nodoc:
     
-      # SECTION: Template Methods (must be implemented by concrete subclass)
+      # :section: Template Methods (must be implemented by concrete subclass)
     
       def facebook_api_key
         raise APIKeyNeededStandardError, "RFACEBOOK ERROR: when using the RFacebook on Rails plugin, please be sure that you have a facebook.yml file with 'key' defined"
@@ -66,7 +66,7 @@ module RFacebook
     
     
     
-      # SECTION: Special Variables
+      # :section: Special Variables
     
       # Function: fbparams
       #   Accessor for all params beginning with "fb_sig_"
@@ -123,10 +123,10 @@ module RFacebook
       
       end
     
-      # SECTION: Helpful Methods
+      # :section: Helpful Methods
     
       # DEPRECATED
-      def facebook_redirect_to(url)
+      def facebook_redirect_to(url) # :nodoc:
         RAILS_DEFAULT_LOGGER.info "** RFACEBOOK DEPRECATION NOTICE: facebook_redirect_to is deprecated in RFacebook. Instead, you can use redirect_to like any Rails app."
         if in_facebook_canvas?
           render :text => "<fb:redirect url=\"#{url}\" />"     
@@ -152,14 +152,23 @@ module RFacebook
       def in_external_app?
         # FIXME: once you click away in an iframe app, you are considered to be an external app
         # TODO: read up on the RFacebook hacks for avoiding nested iframes
-        return (!params[:fb_sig] and !in_facebook_frame?)
+        return (params["fb_sig"] == nil and !in_facebook_frame?)
       end
       
       def added_facebook_application?
-        return fbparams["added"].to_i == 1
+        return (params["fb_sig_added"] != nil)# and params["fb_sig_in_iframe"] == "1")
       end
       
-      # SECTION: before_filters
+      def facebook_platform_signature_verified?
+        return (fbparams and fparams.size > 0)
+      end
+      
+      # TODO: define something along the lines of is_logged_in_to_facebook? that returns fbsession.is_ready? perhaps
+      
+      ################################################################################################
+      ################################################################################################
+      # :section: Before_filters
+      ################################################################################################
           
       def handle_facebook_login
                         
@@ -209,10 +218,7 @@ module RFacebook
       end
     
       def require_facebook_login
-      
-        # handle a facebook login if given (external sites and iframe only)
-        handle_facebook_login
-      
+            
         # now finish it off depending on whether we are in canvas, iframe, or external app
         if !performed?
                 
@@ -262,44 +268,16 @@ module RFacebook
         return true
       end
       
-      # SECTION: Facebook Debug Panel
+      ################################################################################################
+      ################################################################################################
+      # :section: Facebook Debug Panel
+      ################################################################################################
       
       def render_with_facebook_debug_panel(options={})
         begin
           renderedOutput = render_to_string(options)
         rescue Exception => e
-          # TODO: make the backtrace rendering better (Evan Weaver's solution seems good, hopefully he'll allow usage of facebook_exceptions)
-          prettyBacktrace = e.backtrace.map do |line|
-            cleanLine = line.gsub(RAILS_ROOT, "").gsub("<", "&lt;").gsub(">", "&gt;")
-            pieces = cleanLine.split("\n")
-            if (pieces and pieces.size> 0)
-              cleanLine = "<ul>"              
-              pieces.each do |piece|
-                if matches = /.*[\/\\]+((.*)\:([0-9]+)\:\s*in\s*\`(.*)\')/.match(piece)
-                  oldPiece = piece
-                  filename = matches[2]
-                  line = matches[3]
-                  method = matches[4]
-                  piece = "<div class='summary'><strong>#{filename}</strong>:<em>#{line}</em> in <strong>#{method}</strong></div>"
-                  piece += "<div class='rawsummary'>#{oldPiece}</div>"
-                end
-                cleanLine += "<li>#{piece}</li>"
-              end
-              cleanLine += "</ul>"
-            end
-            "<tr><td>#{cleanLine}</td></tr>"
-          end
-          renderedOutput = "
-          <div class='RFacebook'>
-            <div class='backtrace'>
-              <table>
-                <tr><td>
-                  <h1>RFacebook <span style='font-weight: normal; color: #6D84B4'>exception backtrace</span></h1>
-                </td></tr>
-                #{prettyBacktrace}
-              </table>
-            </div>
-          </div>"
+          renderedOutput = facebook_canvas_backtrace(e)
         end
         render_text "#{facebook_debug_panel}#{renderedOutput}"
       end
@@ -309,7 +287,49 @@ module RFacebook
         return ERB.new(template).result(Proc.new{})
       end
       
-      def facebook_status_manager
+      # def rescue_action(exception)
+      #   # TODO: for security, we only do this in development in the canvas
+      #   if (in_facebook_canvas? and RAILS_ENV == "development")
+      #     render_text "#{facebook_debug_panel}#{facebook_canvas_backtrace(exception)}"
+      #   else
+      #     # otherwise, do the default
+      #     super
+      #   end
+      # end
+      
+      def facebook_canvas_backtrace(exception)
+        
+        # TODO: potentially integrate features from Evan Weaver's facebook_exceptions
+        rfacebookBacktraceLines = []
+        exception.backtrace.each do |line|
+          
+          # escape HTML
+          cleanLine = line.gsub(RAILS_ROOT, "").gsub("<", "&lt;").gsub(">", "&gt;")
+          
+          # split up these lines by carriage return
+          pieces = cleanLine.split("\n")
+          if (pieces and pieces.size> 0)
+            pieces.each do |piece|
+              if matches = /.*[\/\\]+((.*)\:([0-9]+)\:\s*in\s*\`(.*)\')/.match(piece)
+                # for each parsed line, add to the array for later rendering in the template
+                rfacebookBacktraceLines << {
+                  :filename => matches[2],
+                  :line => matches[3],
+                  :method => matches[4],
+                  :rawsummary => piece,
+                }
+              end
+            end
+          end
+        end
+        
+        # render to the ERB template
+        template = File.read(File.dirname(__FILE__) + "/templates/exception_backtrace.rhtml")
+        return ERB.new(template).result(Proc.new{})
+
+      end
+      
+      def facebook_status_manager # :nodoc:
         checks = [
           SessionStatusCheck.new(self),
           (FacebookParamsStatusCheck.new(self) unless (!in_facebook_canvas? and !in_facebook_frame?)),
@@ -324,9 +344,12 @@ module RFacebook
         return StatusManager.new(checks)
       end
       
-      # SECTION: Private Methods
+      ################################################################################################
+      ################################################################################################
+      # :section: RFacebook Private Methods
+      ################################################################################################
       
-      def rfacebook_session_holder
+      def rfacebook_session_holder # :nodoc:
         
         if (@rfacebook_session_holder == nil)
           @rfacebook_session_holder = FacebookWebSession.new(facebook_api_key, facebook_api_secret)
@@ -337,7 +360,7 @@ module RFacebook
         
       end
             
-      def rfacebook_persist_session_to_rails
+      def rfacebook_persist_session_to_rails # :nodoc:
         if (!in_facebook_canvas? and rfacebook_session_holder.is_valid?)
           RAILS_DEFAULT_LOGGER.debug "** RFACEBOOK INFO: persisting Facebook session information into Rails session"
           session[:rfacebook_session] = @rfacebook_session_holder.dup
@@ -346,9 +369,12 @@ module RFacebook
       end
       
       
-      # SECTION: URL Management
+      ################################################################################################
+      ################################################################################################
+      # :section: URL Management
+      ################################################################################################
       
-      def url_for__RFACEBOOK(options={}, *parameters)
+      def url_for__RFACEBOOK(options={}, *parameters) # :nodoc:
         
         # error check
         if !options
@@ -358,7 +384,12 @@ module RFacebook
         # use special URL rewriting when inside the canvas
         # setting the mock_ajax option to true will override this
         # and force usage of regular Rails rewriting
-        if (in_facebook_canvas? and !options[:mock_ajax]) #TODO: do something separate for in_facebook_frame?
+        mockajaxSpecified = false
+        if options.is_a? Hash
+          mockajaxSpecified = options[:mock_ajax]
+        end
+          
+        if (in_facebook_canvas? and !mockajaxSpecified) #TODO: do something separate for in_facebook_frame?
           
           if options.is_a? Hash
             options[:only_path] = true
@@ -386,7 +417,7 @@ module RFacebook
           end
         
         # mock-ajax rewriting
-        elsif options[:mock_ajax]
+        elsif mockajaxSpecified
           options.delete(:mock_ajax) # clear it so it doesnt show up in the url
           options[:only_path] = true
           path = "#{request.protocol}#{request.host}:#{request.port}#{url_for__ALIASED(options, *parameters)}"
@@ -399,7 +430,7 @@ module RFacebook
         return path
       end
       
-      def redirect_to__RFACEBOOK(options = {}, *parameters)
+      def redirect_to__RFACEBOOK(options = {}, *parameters) # :nodoc:
         if in_facebook_canvas?
           
           canvasRedirUrl = url_for(options, *parameters)          
@@ -413,11 +444,14 @@ module RFacebook
       end
    
       
-      # SECTION: Extension Helpers
+      ################################################################################################
+      ################################################################################################
+      # :section: Extension Helpers
+      ################################################################################################
       
-      CLASSES_EXTENDED = []
+      CLASSES_EXTENDED = [] # :nodoc:
             
-      def self.included(base)
+      def self.included(base) # :nodoc:
         
         # check for a double include
         doubleInclude = false
@@ -445,6 +479,9 @@ module RFacebook
             alias_method(:redirect_to, :redirect_to__RFACEBOOK)
           '
           
+          # ensure that every action handles facebook login
+          base.before_filter(:handle_facebook_login)
+          
           # ensure that we persist the Facebook session into the Rails session (if possible)
           base.after_filter(:rfacebook_persist_session_to_rails)
           

data/lib/rfacebook_on_rails/model_extensions.rb

@@ -32,28 +32,34 @@ module RFacebook
   module Rails
     module ModelExtensions
       
-      # SECTION: StandardErrors
+      ##################################################################
+      ##################################################################
+      # :section: Errors
+      ##################################################################
     
-      class APIKeyNeededStandardError < StandardError; end
-      class APISecretNeededStandardError < StandardError; end
+      class APIKeyNeededStandardError < StandardError; end # :nodoc:
+      class APISecretNeededStandardError < StandardError; end # :nodoc:
       
-      # SECTION: Template Methods (must be implemented by concrete subclass)
-    
+      ##################################################################
+      ##################################################################
+      # :section: Template Methods (must be implemented by concrete subclass)
+      ##################################################################
+
       def facebook_api_key
-        raise APIKeyNeededStandardError
+        raise APIKeyNeededStandardError, "RFACEBOOK ERROR: when using the RFacebook on Rails plugin, please be sure that you have a facebook.yml file with 'key' defined"
       end
     
       def facebook_api_secret
-        raise APISecretNeededStandardError
+        raise APISecretNeededStandardError, "RFACEBOOK ERROR: when using the RFacebook on Rails plugin, please be sure that you have a facebook.yml file with 'secret' defined"
       end
       
-      # SECTION: ActsAs method mixing
+      # :section: ActsAs method mixing
       
-      def self.included(base)
+      def self.included(base) # :nodoc:
         base.extend ActsAsMethods
       end
 
-      module ActsAsMethods
+      module ActsAsMethods # :nodoc:all
         def acts_as_facebook_user
           include RFacebook::Rails::ModelExtensions::ActsAsFacebookUser::InstanceMethods
           extend RFacebook::Rails::ModelExtensions::ActsAsFacebookUser::ClassMethods
@@ -63,7 +69,8 @@ module RFacebook
       
       ##################################################################
       ##################################################################
-      # SECTION: Acts As Facebook User
+      # :section: Acts As Facebook User
+      ##################################################################
       module ActsAsFacebookUser
         
         ACTORS = [] # holds a reference to all classes that have ActsAsFacebookUser injected
@@ -99,6 +106,10 @@ module RFacebook
           "tv",
           "wall_count",
           "work_history",
+          "pic",
+          "pic_big",
+          "pic_small",
+          "pic_square"
         ]
 
         
@@ -106,13 +117,29 @@ module RFacebook
         module ClassMethods
                     
           def find_or_create_by_facebook_session(sess)
-            instance = find_by_facebook_uid(sess.session_user_id)
-            if !instance
-              instance = self.new
+            if sess.is_ready?
+              
+              # try to find, else create
+              instance = find_by_facebook_uid(sess.session_user_id)
+              if !instance
+                instance = self.new
+              end
+              
+              # update session info
+              instance.facebook_session = sess
+              
+              # update (or create) the object and return it
+              if !instance.save
+                RAILS_DEFAULT_LOGGER.debug "** RFACEBOOK INFO: failed to update or create the Facebook user object in the database"
+                return nil
+              end
+              return instance
+
+            else              
+              RAILS_DEFAULT_LOGGER.info "** RFACEBOOK WARNING: tried to use an inactive session for acts_as_facebook_user (in find_or_create_by_facebook_session)"
+              return nil
             end
-            instance.facebook_session = sess
-            instance.save
-            return instance
+              
           end
                             
         end
@@ -122,9 +149,9 @@ module RFacebook
           
           def facebook_session
             if !@facebook_session
-              self.facebook_session = FacebookWebSession.new(self.facebook_api_key, self.facebook_api_secret)
+              @facebook_session = FacebookWebSession.new(self.facebook_api_key, self.facebook_api_secret)
               begin
-                self.facebook_session.activate_with_previous_session(self.facebook_session_key, self.facebook_uid)
+                @facebook_session.activate_with_previous_session(self.facebook_session_key, self.facebook_uid)
               rescue
                 # not a valid facebook session, should we nil it out?
               end
@@ -139,16 +166,17 @@ module RFacebook
           end
 
           def has_infinite_session_key?
+            # TODO: this check should really look at expires
             return self.facebook_session_key != nil
           end
           
-          def self.included(base)
+          def self.included(base) # :nodoc:
             ActsAsFacebookUser::ACTORS << base
             ActsAsFacebookUser::FIELDS.each do |fieldname|
-              base.class_eval <<-end_eval
+              base.class_eval <<-EOF
                 
                 def #{fieldname}
-                  if facebook_session.is_valid?
+                  if facebook_session.is_ready?
                     return facebook_session.cached_users_getInfo(
                       :uids => [facebook_uid],
                       :fields => ActsAsFacebookUser::FIELDS).user.send(:#{fieldname})
@@ -157,7 +185,7 @@ module RFacebook
                   end
                 end
               
-              end_eval
+              EOF
             end
           end
                 

data/lib/rfacebook_on_rails/plugin/init.rb

@@ -90,9 +90,19 @@ end
 
 # load Facebook configuration file (credit: Evan Weaver)
 begin
-  FACEBOOK = YAML.load_file("#{RAILS_ROOT}/config/facebook.yml")[RAILS_ENV]
-rescue
-  FACEBOOK = {}
+  yamlFile = YAML.load_file("#{RAILS_ROOT}/config/facebook.yml")
+rescue Exception => e
+  raise StandardError, "config/facebook.yml could not be loaded."
+end
+
+if yamlFile
+  if yamlFile[RAILS_ENV]
+    FACEBOOK =  yamlFile[RAILS_ENV]
+  else
+    raise StandardError, "config/facebook.yml exists, but doesn't have a configuration for RAILS_ENV=#{RAILS_ENV}."
+  end
+else
+  raise StandardError, "config/facebook.yml does not exist."
 end
 
 # parse for full URLs in facebook.yml (multiple people have made this mistake)

data/lib/rfacebook_on_rails/plugin/rake.rb

@@ -35,7 +35,7 @@ namespace "facebook" do
   ######################################################################################
   ######################################################################################
   desc "Sets up the RFacebook Rails Plugin.  Right now, this simply copies facebook.yml into your config directory."
-  task "setup" => "environment" do
+  task "setup" do
     
     filename = "#{RAILS_ROOT}/config/facebook.yml"
     puts "======================================================"