clickonchris-facebooker2 0.0.7.x1

data/lib/facebooker2.rb

@@ -0,0 +1,50 @@
+# Facebooker2
+require "mogli"
+module Facebooker2
+  class NotConfigured < Exception; end
+  class << self
+    attr_accessor :api_key, :secret, :app_id
+  end
+    
+  def self.secret
+    @secret || raise_unconfigured_exception    
+  end
+  
+  def self.app_id
+    @app_id || raise_unconfigured_exception
+  end
+  
+  def self.raise_unconfigured_exception
+    raise NotConfigured.new("No configuration provided for Facebooker2. Either set the app_id and secret or call Facebooker2.load_facebooker_yaml in an initializer")
+  end
+  
+  def self.configuration=(hash)
+    self.api_key = hash[:api_key]
+    self.secret = hash[:secret]
+    self.app_id = hash[:app_id]
+  end
+  
+  def self.load_facebooker_yaml
+    config = YAML.load(ERB.new(File.read(File.join(::Rails.root,"config","facebooker.yml"))).result)[::Rails.env]
+    raise NotConfigured.new("Unable to load configuration for #{::Rails.env} from facebooker.yml. Is it set up?") if config.nil?
+    self.configuration = config.with_indifferent_access
+  end
+  
+  def self.cast_to_facebook_id(object)
+    if object.kind_of?(Mogli::Profile)
+      object.id
+    elsif object.respond_to?(:facebook_id)
+      object.facebook_id
+    else
+      object
+    end
+  end
+end
+
+
+require "facebooker2/rails/controller"
+require "facebooker2/rails/helpers/facebook_connect"
+require "facebooker2/rails/helpers/javascript"
+require "facebooker2/rails/helpers/request_forms"
+require "facebooker2/rails/helpers/user"
+require "facebooker2/rails/helpers"

data/lib/facebooker2/rails.rb

@@ -0,0 +1,4 @@
+module Facebooker2
+  module Rails
+  end
+end

data/lib/facebooker2/rails/controller.rb

@@ -0,0 +1,180 @@
+require "digest/md5"
+require "hmac-sha2"
+module Facebooker2
+  module Rails
+    module Controller
+      
+      def self.included(controller)
+        controller.helper Facebooker2::Rails::Helpers
+        controller.helper_method :current_facebook_user
+        controller.helper_method :current_facebook_client
+        controller.helper_method :facebook_params
+      end
+      
+      def current_facebook_user
+        fetch_client_and_user
+        @_current_facebook_user
+      end
+      
+      def current_facebook_client
+        fetch_client_and_user
+        @_current_facebook_client
+      end
+      
+      # This mimics the getSession logic from the php facebook SDK
+      # https://github.com/facebook/php-sdk/blob/master/src/facebook.php#L333
+      #
+      def fetch_client_and_user
+        return if @_fb_user_fetched
+        # Try to authenticate from the signed request first
+        sig = fetch_client_and_user_from_signed_request
+        sig = fetch_client_and_user_from_cookie unless @_current_facebook_client
+        
+        #write the authentication params to a new cookie
+        if !@_current_facebook_client.nil? 
+          #we may have generated the signature based on the params in @facebook_params, and the expiration here is different
+          
+          set_fb_cookie(@_current_facebook_client.access_token, @_current_facebook_client.expiration, @_current_facebook_user.id, sig)
+        else
+          # if we do not have a client, delete the cookie
+          set_fb_cookie(nil,nil,nil,nil)
+        end
+        
+        @_fb_user_fetched = true
+      end
+      
+      def fetch_client_and_user_from_cookie
+        if (hash_data = fb_cookie_hash) and
+          fb_cookie_signature_correct?(fb_cookie_hash,Facebooker2.secret)
+          fb_create_user_and_client(hash_data["access_token"],hash_data["expires"],hash_data["uid"])
+          return fb_cookie_hash["sig"]
+        end
+      end
+      
+      def fb_create_user_and_client(token,expires,userid)
+        client = Mogli::Client.new(token,expires.to_i)
+        user = Mogli::User.new(:id=>userid)
+        fb_sign_in_user_and_client(user,client)
+      end
+            
+      def fb_sign_in_user_and_client(user,client)
+        user.client = client
+        @_current_facebook_user = user
+        @_current_facebook_client = client
+        @_fb_user_fetched = true
+      end
+      
+      def fb_cookie_hash
+        return nil unless fb_cookie?
+        hash={}
+        data = fb_cookie.gsub(/"/,"")
+        data.split("&").each do |str|
+          parts = str.split("=")
+          hash[parts.first] = parts.last
+        end
+        hash
+      end
+      
+      def fb_cookie?
+        !fb_cookie.nil?
+      end
+      
+      def fb_cookie
+        cookies[fb_cookie_name]
+      end
+      
+      def fb_cookie_name
+        return "fbs_#{Facebooker2.app_id}"
+      end
+      
+      # check if the expected signature matches the one from facebook
+      def fb_cookie_signature_correct?(hash,secret)
+        generateSignature(hash,secret) == hash["sig"]
+      end
+      
+      # compute the md5 sig based on access_token,expires,uid, and the app secret
+      def generateSignature(hash,secret)
+        sorted_keys = hash.keys.reject {|k| k=="sig"}.sort
+        test_string = ""
+        sorted_keys.each do |key|
+          test_string += "#{key}=#{hash[key]}"
+        end
+        test_string += secret
+        sig = Digest::MD5.hexdigest(test_string)
+        return sig
+      end
+      
+      def fb_signed_request_json(encoded)
+        chars_to_add = 4-(encoded.size % 4)
+        encoded += ("=" * chars_to_add)
+        Base64.decode64(encoded)
+      end
+      
+      def facebook_params
+        @facebook_param ||= fb_load_facebook_params
+      end
+
+      def fb_load_facebook_params
+        return {} if params[:signed_request].blank?
+        sig,encoded_json = params[:signed_request].split(".")
+        return {} unless fb_signed_request_sig_valid?(sig,encoded_json)
+        ActiveSupport::JSON.decode(fb_signed_request_json(encoded_json)).with_indifferent_access
+      end  
+      
+      def fb_signed_request_sig_valid?(sig,encoded) 
+        base64 = Base64.encode64(HMAC::SHA256.digest(Facebooker2.secret,encoded))
+        #now make the url changes that facebook makes
+        url_escaped_base64 = base64.gsub(/=*\n?$/,"").tr("+/","-_")
+        sig ==  url_escaped_base64
+      end
+      
+      def fetch_client_and_user_from_signed_request
+        if facebook_params[:oauth_token]
+          fb_create_user_and_client(facebook_params[:oauth_token],facebook_params[:expires],facebook_params[:user_id])
+          
+          if @_current_facebook_client
+            #compute a signature so we can store it in the cookie
+            sig_hash = Hash["uid"=>facebook_params[:user_id],"access_token"=>facebook_params[:oauth_token],"expires"=>facebook_params[:expires]]
+            return generateSignature(sig_hash, Facebooker2.secret)
+          end
+        end
+      end
+      
+      
+      # /**
+      #   This method was shamelessly stolen from the php facebook SDK:
+      #   https://github.com/facebook/php-sdk/blob/master/src/facebook.php
+      #   
+      #    Set a JS Cookie based on the _passed in_ session. It does not use the
+      #    currently stored session -- you need to explicitly pass it in.
+      #   
+      #   If a nil access_token is passed in this method will actually delete the fbs_ cookie
+      #
+      #   */
+      def set_fb_cookie(access_token,expires,uid,sig) 
+        
+        #default values for the cookie
+        value = 'deleted'
+        expires = Time.now.utc - 3600 unless expires != nil
+        
+        if access_token
+          value = '"uid=' + uid + '&' +
+                  'access_token=' + access_token + '&' +
+                  'expires=' + expires.to_i.to_s + '&' +
+                  'sig=' + sig + '"'
+        end
+  
+        # if an existing cookie is not set, we dont need to delete it
+        if (value == 'deleted' && cookies[fb_cookie_name] == "" ) 
+          return;
+        end
+    
+        # in php they have to check if headers have already been sent before setting the cookie
+        # maybe rails we don't have this problem?
+        
+        #My browser doesn't seem to save the cookie if I set expires
+        cookies[fb_cookie_name] = { :value=>value }#, :expires=>expires}
+      end
+    end
+  end
+end

data/lib/facebooker2/rails/helpers.rb

@@ -0,0 +1,33 @@
+module Facebooker2
+  module Rails
+    module Helpers
+      include FacebookConnect
+      include Javascript
+      include RequestForms
+      include User
+      
+       def fb_stringify_vals(hash)
+        result={}
+        hash.each do |key,value|
+          result[key]=value.to_s
+        end
+        result
+       end
+        def fb_transform_keys(options,transformation_hash)
+          new_hash = {}
+          options.each do |key,value|
+            new_key = transformation_hash[key]||key
+            new_hash[new_key]=value
+          end
+          new_hash
+        end
+        FB_ALWAYS_VALID_OPTION_KEYS = [:class, :style]
+      
+      def fb_assert_valid_keys(options,*valid_keys)
+        unknown_keys = options.keys - [valid_keys + FB_ALWAYS_VALID_OPTION_KEYS].flatten
+        raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+      end    
+      
+    end
+  end
+end

data/lib/facebooker2/rails/helpers/facebook_connect.rb

@@ -0,0 +1,52 @@
+module Facebooker2
+  module Rails
+    module Helpers
+      module FacebookConnect 
+        #
+        # Render an <fb:login-button> element, similar to
+        # fb_login_button. Adds a js redirect to the onlogin event via rjs.
+        #
+        # ==== Examples
+        #
+        #   fb_login_and_redirect '/other_page'
+        #   => <fb:login-button onlogin="window.location.href = &quot;/other_page&quot;;"></fb:login-button>
+        #
+        # Like #fb_login_button, this also supports the :text option
+        #
+        #   fb_login_and_redirect '/other_page', :text => "Login with Facebook", :v => '2'
+        #   => <fb:login-button onlogin="window.location.href = &quot;/other_page&quot;;" v="2">Login with Facebook</fb:login-button>
+        #
+        def fb_login_and_redirect(url, options = {})
+          js = update_page do |page|
+            page.redirect_to url
+          end
+
+          text = options.delete(:text)
+          
+          #rails 3 only escapes non-html_safe strings, so get the raw string instead of the SafeBuffer
+          content_tag("fb:login-button",text,options.merge(:onlogin=>js.to_str))
+        end
+        
+        def fb_login(options = {},&proc)
+           js = capture(&proc)
+           text = options.delete(:text)
+           concat(content_tag("fb:login-button",text,options.merge(:onlogin=>js.to_str)))
+        end
+        
+        #
+        # Logs the user out of facebook and redirects to the given URL
+        #  args are passed to the call to link_to_function
+        def fb_logout_link(text,url,*args)
+          function= "FB.logout(function() {window.location.href = '#{url}';})"
+          link_to_function text, function.to_str, *args
+        end
+        
+        def fb_server_fbml(style=nil,&proc)
+          style_string=" style=\"#{style}\"" if style
+          content = capture(&proc)
+          concat("<fb:serverFbml#{style_string}><script type='text/fbml'>#{content}</script></fb:serverFbml>")
+        end
+      end
+    end
+  end
+end

data/lib/facebooker2/rails/helpers/javascript.rb

@@ -0,0 +1,56 @@
+module Facebooker2
+  module Rails
+    module Helpers
+      module Javascript
+        
+        def fb_html_safe(str)
+          if str.respond_to?(:html_safe)
+            str.html_safe
+          else
+            str
+          end
+        end
+        
+        def fb_connect_async_js(app_id=Facebooker2.app_id,options={},&proc)
+          opts = Hash.new(true).merge!(options)
+          cookie = opts[:cookie]
+          status = opts[:status]
+          xfbml = opts[:xfbml]
+          extra_js = capture(&proc) if block_given?
+          js = <<-JAVASCRIPT
+          <script>
+            window.fbAsyncInit = function() {
+              FB.init({
+                appId  : '#{app_id}',
+                status : #{status}, // check login status
+                cookie : #{cookie}, // enable cookies to allow the server to access the session
+                xfbml  : #{xfbml}  // parse XFBML
+              });
+              #{extra_js}
+            };
+
+            (function() {
+              var s = document.createElement('div'); 
+              s.setAttribute('id','fb-root'); 
+              document.documentElement.getElementsByTagName("body")[0].appendChild(s);
+              var e = document.createElement('script');
+              e.src = document.location.protocol + '//connect.facebook.net/en_US/all.js';
+              e.async = true;
+              s.appendChild(e);
+            }());
+          </script>
+          JAVASCRIPT
+          escaped_js = fb_html_safe(js)
+          if block_given? 
+           concat(escaped_js)
+           #return the empty string, since concat returns the buffer and we don't want double output
+           # from klochner
+           "" 
+          else
+           escaped_js
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facebooker2/rails/helpers/request_forms.rb

@@ -0,0 +1,33 @@
+module Facebooker2
+  module Rails
+    module Helpers
+      module RequestForms
+        def fb_req_choice(label,url)
+          tag "fb:req-choice",:label=>label,:url=>url
+        end
+        
+        def fb_multi_friend_selector(message,options={},&block)
+          options = fb_stringify_vals({:showborder=>false,:actiontext=>message,:max=>20}.merge(options.dup))
+          tag("fb:multi-friend-selector",options)
+        end
+        
+        def fb_request_form(type,url,message,options={},&block)
+          content = capture(&block)
+          concat(content_tag("fb:request-form", content.to_s + fb_forgery_protection_token_tag,
+                    {:action=>url,:method=>"post",:invite=>true,:type=>type,:content=>message}.merge(options)))
+        end
+        
+        
+        def fb_forgery_protection_token_tag
+          unless protect_against_forgery?
+            ''
+          else
+            tag(:input, :type => "hidden", :name => request_forgery_protection_token.to_s, :value => form_authenticity_token)
+          end
+        end
+        
+        
+      end
+    end
+  end
+end

data/lib/facebooker2/rails/helpers/user.rb

@@ -0,0 +1,49 @@
+module Facebooker2
+  module Rails
+    module Helpers
+      module User
+        # Render an fb:name tag for the given user
+        # This renders the name of the user specified.  You can use this tag as both subject and object of 
+        # a sentence.  <em> See </em> http://wiki.developers.facebook.com/index.php/Fb:name for full description.  
+        # Use this tag on FBML pages instead of retrieving the user's info and rendering the name explicitly.
+        #
+        def fb_name(user, options={})
+          options = fb_transform_keys(options,FB_NAME_OPTION_KEYS_TO_TRANSFORM)
+          fb_assert_valid_keys(options, FB_NAME_VALID_OPTION_KEYS)
+          options.merge!(:uid => Facebooker2.cast_to_facebook_id(user))
+          content_tag("fb:name",nil, fb_stringify_vals(options))
+        end
+
+        FB_NAME_OPTION_KEYS_TO_TRANSFORM = {:first_name_only => :firstnameonly, 
+                                            :last_name_only => :lastnameonly,
+                                            :show_network => :shownetwork,
+                                            :use_you => :useyou,
+                                            :if_cant_see => :ifcantsee,
+                                            :subject_id => :subjectid}
+        FB_NAME_VALID_OPTION_KEYS = [:firstnameonly, :linked, :lastnameonly, :possessive, :reflexive, 
+                                     :shownetwork, :useyou, :ifcantsee, :capitalize, :subjectid]
+        
+        
+        def fb_profile_pic(user, options={})
+          options = options.dup
+          validate_fb_profile_pic_size(options)
+          options = fb_transform_keys(options,FB_PROFILE_PIC_OPTION_KEYS_TO_TRANSFORM)
+          fb_assert_valid_keys(options,FB_PROFILE_PIC_VALID_OPTION_KEYS)
+          options.merge!(:uid => Facebooker2.cast_to_facebook_id(user))
+          content_tag("fb:profile-pic", nil,fb_stringify_vals(options))
+        end
+
+        FB_PROFILE_PIC_OPTION_KEYS_TO_TRANSFORM = {:facebook_logo => 'facebook-logo'}
+        FB_PROFILE_PIC_VALID_OPTION_KEYS = [:size, :linked, 'facebook-logo', :width, :height]
+        VALID_FB_PROFILE_PIC_SIZES = [:thumb, :small, :normal, :square]
+        def validate_fb_profile_pic_size(options)
+          if options.has_key?(:size) && !VALID_FB_PROFILE_PIC_SIZES.include?(options[:size].to_sym)
+            raise(ArgumentError, "Unknown value for size: #{options[:size]}")
+          end
+        end
+
+       
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: clickonchris-facebooker2
+version: !ruby/object:Gem::Version 
+  hash: 113
+  prerelease: 6
+  segments: 
+  - 0
+  - 0
+  - 7
+  - x
+  - 1
+  version: 0.0.7.x1
+platform: ruby
+authors: 
+- Mike Mangino (patch by Chris Johnson)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-27 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mogli
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 0
+        - 12
+        version: 0.0.12
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ruby-hmac
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Facebook Connect integration library for ruby and rails
+email: chris@clickonchris.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/facebooker2/rails/controller.rb
+- lib/facebooker2/rails/helpers/facebook_connect.rb
+- lib/facebooker2/rails/helpers/javascript.rb
+- lib/facebooker2/rails/helpers/request_forms.rb
+- lib/facebooker2/rails/helpers/user.rb
+- lib/facebooker2/rails/helpers.rb
+- lib/facebooker2/rails.rb
+- lib/facebooker2.rb
+has_rdoc: true
+homepage: http://developers.facebook.com/docs/api
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Facebook Connect integration library for ruby and rails
+test_files: []
+