hashrocket-clearance 0.4.0

data/test/rails_root/vendor/plugins/facebooker/lib/facebooker/rails/controller.rb

@@ -0,0 +1,246 @@
+require 'facebooker'
+require 'facebooker/rails/profile_publisher_extensions'
+module Facebooker
+  module Rails
+    module Controller
+      include Facebooker::Rails::ProfilePublisherExtensions
+      def self.included(controller)
+        controller.extend(ClassMethods)
+        controller.before_filter :set_adapter
+        controller.before_filter :set_fbml_format
+        controller.helper_attr :facebook_session_parameters
+        controller.helper_method :request_comes_from_facebook?
+      end
+
+    
+      def facebook_session
+        @facebook_session
+      end
+      
+      def facebook_session_parameters
+        {:fb_sig_session_key=>params[:fb_sig_session_key]}
+      end
+      
+      
+      def set_facebook_session
+        
+        returning session_set = session_already_secured? ||  secure_with_facebook_params! ||secure_with_token!  do
+          if session_set
+            capture_facebook_friends_if_available! 
+            Session.current = facebook_session
+          end
+        end
+      end
+      
+      def facebook_params
+        @facebook_params ||= verified_facebook_params
+      end      
+      
+      private
+      
+      def session_already_secured?
+        (@facebook_session = session[:facebook_session]) && session[:facebook_session].secured? if valid_session_key_in_session?
+      end
+      
+      def user_has_deauthorized_application?
+        # if we're inside the facebook session and there is no session key,
+        # that means the user revoked our access
+        # we don't want to keep using the old expired key from the cookie. 
+        request_comes_from_facebook? and params[:fb_sig_session_key].blank?
+      end
+      
+      def clear_facebook_session_information
+        session[:facebook_session] = nil
+        @facebook_session=nil        
+      end
+      
+      def valid_session_key_in_session?
+        #before we access the facebook_params, make sure we have the parameters
+        #otherwise we will blow up trying to access the secure parameters
+        if user_has_deauthorized_application?
+          clear_facebook_session_information
+          false
+        else
+          !session[:facebook_session].blank? &&  (params[:fb_sig_session_key].blank? || session[:facebook_session].session_key == facebook_params[:session_key])
+        end
+      end
+            
+      def secure_with_token!
+        if params['auth_token']
+          @facebook_session = new_facebook_session
+          @facebook_session.auth_token = params['auth_token']
+          @facebook_session.secure!
+          session[:facebook_session] = @facebook_session
+        end
+      end
+      
+      def secure_with_facebook_params!
+        return unless request_comes_from_facebook?
+        
+        if ['user', 'session_key'].all? {|element| facebook_params[element]}
+          @facebook_session = new_facebook_session
+          @facebook_session.secure_with!(facebook_params['session_key'], facebook_params['user'], facebook_params['expires'])
+          session[:facebook_session] = @facebook_session
+        end
+      end
+      
+      #override to specify where the user should be sent after logging in
+      def after_facebook_login_url
+        nil
+      end
+      
+      def create_new_facebook_session_and_redirect!
+        session[:facebook_session] = new_facebook_session
+        url_params = after_facebook_login_url.nil? ? {} : {:next=>after_facebook_login_url}
+        redirect_to session[:facebook_session].login_url(url_params) unless @installation_required
+        false
+      end
+      
+      def new_facebook_session
+        Facebooker::Session.create(Facebooker.api_key, Facebooker.secret_key)
+      end
+      
+      def capture_facebook_friends_if_available!
+        return unless request_comes_from_facebook?
+        if friends = facebook_params['friends']
+          facebook_session.user.friends = friends.map do |friend_uid|
+            User.new(friend_uid, facebook_session)
+          end
+        end
+      end
+            
+      def blank?(value)
+        (value == '0' || value.nil? || value == '')        
+      end
+
+      def verified_facebook_params
+        facebook_sig_params = params.inject({}) do |collection, pair|
+          collection[pair.first.sub(/^fb_sig_/, '')] = pair.last if pair.first[0,7] == 'fb_sig_'
+          collection
+        end
+        verify_signature(facebook_sig_params,params['fb_sig'])
+
+        facebook_sig_params.inject(HashWithIndifferentAccess.new) do |collection, pair| 
+          collection[pair.first] = facebook_parameter_conversions[pair.first].call(pair.last)
+          collection
+        end
+      end
+      
+      def earliest_valid_session
+        48.hours.ago
+      end
+      
+      def verify_signature(facebook_sig_params,expected_signature)
+        raw_string = facebook_sig_params.map{ |*args| args.join('=') }.sort.join
+        actual_sig = Digest::MD5.hexdigest([raw_string, Facebooker::Session.secret_key].join)
+        raise Facebooker::Session::IncorrectSignature if actual_sig != expected_signature
+        raise Facebooker::Session::SignatureTooOld if Time.at(facebook_sig_params['time'].to_f) < earliest_valid_session
+        true
+      end
+      
+      def facebook_parameter_conversions
+        @facebook_parameter_conversions ||= Hash.new do |hash, key| 
+          lambda{|value| value}
+        end.merge(
+          'time' => lambda{|value| Time.at(value.to_f)},
+          'in_canvas' => lambda{|value| !blank?(value)},
+          'added' => lambda{|value| !blank?(value)},
+          'expires' => lambda{|value| blank?(value) ? nil : Time.at(value.to_f)},
+          'friends' => lambda{|value| value.split(/,/)}
+        )
+      end
+      
+      def redirect_to(*args)
+        if request_is_for_a_facebook_canvas? and !request_is_facebook_tab?
+          render :text => fbml_redirect_tag(*args)
+        else
+          super
+        end
+      end
+      
+      def fbml_redirect_tag(url)
+        "<fb:redirect url=\"#{url_for(url)}\" />"
+      end
+      
+      def request_comes_from_facebook?
+        request_is_for_a_facebook_canvas? || request_is_facebook_ajax?
+      end
+      
+      def request_is_for_a_facebook_canvas?
+        !params['fb_sig_in_canvas'].blank?
+      end
+      
+      def request_is_facebook_tab?
+        !params["fb_sig_in_profile_tab"].blank?
+      end
+      
+      def request_is_facebook_ajax?
+        params["fb_sig_is_mockajax"]=="1" || params["fb_sig_is_ajax"]=="1"
+      end
+      def xml_http_request?
+        request_is_facebook_ajax? || super
+      end
+      
+      
+      
+      def application_is_installed?
+        facebook_params['added']
+      end
+      
+      def ensure_has_status_update
+        has_extended_permission?("status_update") || application_needs_permission("status_update")
+      end
+      def ensure_has_photo_upload
+        has_extended_permission?("photo_upload") || application_needs_permission("photo_upload")
+      end
+      def ensure_has_create_listing
+        has_extended_permission?("create_listing") || application_needs_permission("create_listing")
+      end
+      
+      def application_needs_permission(perm)
+        redirect_to(facebook_session.permission_url(perm))
+      end
+      
+      def has_extended_permission?(perm)
+        params["fb_sig_ext_perms"] and params["fb_sig_ext_perms"].include?(perm)
+      end
+      
+      def ensure_authenticated_to_facebook
+        set_facebook_session || create_new_facebook_session_and_redirect!
+      end
+      
+      def ensure_application_is_installed_by_facebook_user
+        @installation_required = true
+        returning ensure_authenticated_to_facebook && application_is_installed? do |authenticated_and_installed|
+           application_is_not_installed_by_facebook_user unless authenticated_and_installed
+        end
+      end
+      
+      def application_is_not_installed_by_facebook_user
+        redirect_to session[:facebook_session].install_url
+      end
+      
+      def set_fbml_format
+        params[:format]="fbml" if request_comes_from_facebook?
+      end
+      def set_adapter
+        Facebooker.load_adapter(params) if(params[:fb_sig_api_key])
+      end
+
+      
+      module ClassMethods
+        #
+        # Creates a filter which reqires a user to have already authenticated to
+        # Facebook before executing actions.  Accepts the same optional options hash which
+        # before_filter and after_filter accept.
+        def ensure_authenticated_to_facebook(options = {})
+          before_filter :ensure_authenticated_to_facebook, options
+        end
+        
+        def ensure_application_is_installed_by_facebook_user(options = {})
+          before_filter :ensure_application_is_installed_by_facebook_user, options
+        end
+      end
+    end
+  end
+end

data/test/rails_root/vendor/plugins/facebooker/lib/facebooker/rails/facebook_asset_path.rb

@@ -0,0 +1,18 @@
+# module ActionView
+#   module Helpers
+#     module AssetTagHelper
+#       def compute_public_path_with_facebooker(*args)
+#         public_path=compute_public_path_without_facebooker(*args)
+#         if public_path.starts_with?(ActionController::Base.asset_host)
+#           str=ActionController::Base.asset_host
+#           str += "/" unless str.ends_with?("/")
+#           public_path.gsub(/#{Regexp.escape(ActionController::Base.asset_host)}#{@controller.request.relative_url_root}\//,str)
+#         else
+#           public_path
+#         end
+#       end
+#       
+#       alias_method_chain :compute_public_path, :facebooker
+#     end
+#   end
+# end

data/test/rails_root/vendor/plugins/facebooker/lib/facebooker/rails/facebook_form_builder.rb

@@ -0,0 +1,112 @@
+module Facebooker
+  module Rails
+    class FacebookFormBuilder < ActionView::Helpers::FormBuilder
+      
+      
+      second_param = %w(password_field file_field check_box date_select datetime_select time_select)
+      third_param = %w(radio_button country_select select time_zone_select)
+      fifth_param = %w(collection_select)
+      
+      def self.create_with_offset(name,offset)
+        define_method name do |field,*args|
+          options = args[offset] || {}
+          build_shell(field,options) do
+            super
+          end
+        end    
+      end
+
+      second_param.each do |name|
+        create_with_offset(name,0)
+      end
+      third_param.each do |name|
+        create_with_offset(name,1)
+      end
+      fifth_param.each do |name|
+        create_with_offset(name,3)
+      end
+      
+      def build_shell(field,options)
+        @template.content_tag "fb:editor-custom", :label=>label_for(field,options) do
+          yield
+        end
+      end
+      
+      def label_for(field,options)
+        options[:label] || field.to_s.humanize
+      end
+      
+      def text(string,options={})
+        @template.content_tag "fb:editor-custom",string, :label=>label_for("",options)
+      end
+      
+      
+      def text_field(method, options = {})
+        options[:label] ||= label_for(method,options)
+        add_default_name_and_id(options,method)
+        options["value"] ||= value_before_type_cast(object,method)
+        @template.content_tag("fb:editor-text","",options)
+      end
+      
+      
+      def text_area(method, options = {})
+        options[:label] ||= label_for(method,options)
+        add_default_name_and_id(options,method)
+        @template.content_tag("fb:editor-textarea",value_before_type_cast(object,method),options)        
+      end
+      
+      #
+      # Build a text input area that uses typeahed
+      # options are like collection_select
+      def collection_typeahead(method,collection,value_method,text_method,options={})
+        build_shell(method,options) do
+          collection_typeahead_internal(method,collection,value_method,text_method,options)
+        end
+      end
+      
+      def collection_typeahead_internal(method,collection,value_method,text_method,options={})
+        option_values = collection.map do |item|
+          value=item.send(value_method)
+          text=item.send(text_method)
+          @template.content_tag "fb:typeahead-option",text,:value=>value
+        end.join
+        add_default_name_and_id(options,method)
+        options["value"] ||= value_before_type_cast(object,method)
+        @template.content_tag("fb:typeahead-input",option_values,options)        
+      end
+      
+      def value_before_type_cast(object,method)
+        unless object.nil?
+          method_name = method.to_s
+          object.respond_to?(method_name + "_before_type_cast") ?
+          object.send(method_name + "_before_type_cast") :
+          object.send(method_name)
+        end
+      end
+      
+      def multi_friend_input(options={})
+        build_shell(:friends,options) do
+          @template.content_tag("fb:multi-friend-input","",options)
+        end
+      end
+
+      def buttons(*names)
+        buttons=names.map do |name|
+          create_button(name)
+        end.join
+        
+        @template.content_tag "fb:editor-buttonset",buttons
+      end
+      
+      def create_button(name)
+        @template.content_tag("fb:editor-button","",:value=>name,:name=>"commit")
+      end
+      
+      def add_default_name_and_id(options,method)
+        options[:name] ||= "#{object.class.name.underscore}[#{method}]"
+        options[:id] ||= "#{object.class.name.underscore}_#{method}"
+      end
+
+    end
+  end
+end

data/test/rails_root/vendor/plugins/facebooker/lib/facebooker/rails/facebook_pretty_errors.rb

@@ -0,0 +1,14 @@
+if Facebooker.facebooker_config['pretty_errors'] || (Facebooker.facebooker_config['pretty_errors'].nil? && RAILS_ENV=="development")
+  class ActionController::Base
+    def rescues_path_with_facebooker(template_name)
+      t="#{RAILS_ROOT}/vendor/plugins/facebooker/templates/#{template_name}.erb"
+      File.exist?(t) ? t : rescues_path_without_facebooker(template_name)
+    end
+
+    alias_method_chain :rescues_path,:facebooker
+
+    def response_code_for_rescue(exception)
+      200
+    end
+  end
+end

data/test/rails_root/vendor/plugins/facebooker/lib/facebooker/rails/facebook_request_fix.rb

@@ -0,0 +1,24 @@
+module ::ActionController
+  class AbstractRequest
+    def request_method_with_facebooker
+      if parameters[:fb_sig_request_method]=="GET" and parameters[:_method].blank?
+        parameters[:_method]="GET"
+      end
+      request_method_without_facebooker
+    end
+    
+    if new.methods.include?("request_method")
+      alias_method_chain :request_method, :facebooker 
+    end
+    
+    def xml_http_request_with_facebooker?
+      parameters["fb_sig_is_mockajax"] == "1"  ||
+      parameters["fb_sig_is_ajax"] == "1" ||
+      xml_http_request_without_facebooker?
+    end
+    alias_method_chain :xml_http_request?, :facebooker
+    # we have to re-alias xhr? since it was pointing to the old method
+    alias xhr? :xml_http_request?
+    
+  end
+end

data/test/rails_root/vendor/plugins/facebooker/lib/facebooker/rails/facebook_session_handling.rb

@@ -0,0 +1,58 @@
+module ActionController
+  class CgiRequest
+    alias :initialize_aliased_by_facebooker :initialize
+
+    def initialize(cgi, session_options = {})
+      initialize_aliased_by_facebooker(cgi, session_options)
+      @cgi.instance_variable_set("@request_params", request_parameters.merge(query_parameters))
+    end
+    
+    DEFAULT_SESSION_OPTIONS[:cookie_only] = false
+  end 
+end
+
+class CGI  
+  class Session
+    private
+      alias :initialize_aliased_by_facebooker :initialize
+      attr_reader :request, :initialization_options
+
+      def initialize(request, option={})
+        @request = request
+        @initialization_options = option
+        option['session_id'] = set_session_id
+        initialize_aliased_by_facebooker(request, option)
+      end
+      
+      def set_session_id
+        if session_key_should_be_set_with_facebook_session_key? 
+          request_parameters[facebook_session_key]
+        else 
+          request_parameters[session_key]
+        end
+      end
+
+      def request_parameters
+        request.instance_variable_get("@request_params")
+      end
+
+      def session_key_should_be_set_with_facebook_session_key?
+        request_parameters[session_key].blank? && !request_parameters[facebook_session_key].blank?
+      end
+
+      def session_key
+        initialization_options['session_key'] || '_session_id'
+      end
+
+      def facebook_session_key
+        'fb_sig_session_key'
+      end
+
+      alias :create_new_id_aliased_by_facebooker :create_new_id
+
+      def create_new_id
+        @new_session = true
+        @session_id || create_new_id_aliased_by_facebooker
+      end
+  end
+end

data/test/rails_root/vendor/plugins/facebooker/lib/facebooker/rails/facebook_url_helper.rb

@@ -0,0 +1,191 @@
+# Extends the ActionView::Helpers::UrlHelper module.  See it for details on
+# the usual url helper methods: url_for, link_to, button_to, etc.  
+#
+# Mostly, the changes sanitize javascript into facebook javascript.  
+# It sanitizes link_to solely by altering the private methods: 
+# convert_options_to_javascript!, confirm_javascript_function, and 
+# method_javascript_function.  For button_to, it alters button_to
+# itself, as well as confirm_javascript_function.  No other methods 
+# need to be changed because of Facebook javascript.
+#
+# For button_to and link_to, adds alternate confirm options for facebook.
+# ==== Options
+# * <tt>:confirm => 'question?'</tt> - This will add a JavaScript confirm
+#   prompt with the question specified.
+#
+#   Example:
+#     # Generates: <a href="http://rubyforge.org/projects/facebooker" onclick="
+#     #			var dlg = new Dialog().showChoice('Please Confirm', 'Go to Facebooker?').setStyle();
+#     #			var a=this;dlg.onconfirm = function() {
+#     #		          document.setLocation(a.getHref()); 
+#     #			}; return false;">Facebooker</a>
+#     link_to("Facebooker", "http://rubyforge.org/projects/facebooker", :confirm=>"Go to Facebooker?")
+#
+#   Alternatively, options[:confirm] may be specified.  
+#   See the Facebook page http://wiki.developers.facebook.com/index.php/FBJS.
+#   These options are:
+#   <tt>:title</tt>::       Specifies the title of the Facebook dialog. Default is "Please Confirm".
+#   <tt>:content</tt>::       Specifies the title of the Facebook dialog. Default is "Are you sure?".
+#
+#   Example:
+#     # Generates: <a href="http://rubyforge.org/projects/facebooker" onclick="
+#     #			var dlg = new Dialog().showChoice('the page says:', 'Go to Facebooker?').setStyle();
+#     #			var a=this;dlg.onconfirm = function() {
+#     #		          document.setLocation(a.getHref()); 
+#     #			}; return false;">Facebooker</a>
+#     link_to("Facebooker", "http://rubyforge.org/projects/facebooker", :confirm=>{:title=>"the page says:", :content=>"Go to Facebooker?"})
+#
+#   Any other options passed are assumed to be css styles.
+#   Again, see the Facebook page http://wiki.developers.facebook.com/index.php/FBJS.
+#
+#   Example:
+#     # Generates: <a href="http://rubyforge.org/projects/facebooker" onclick="
+#     #			var dlg = new Dialog().showChoice('the page says:', 'Are you sure?').setStyle({color: 'pink', width: '200px'});
+#     #			var a=this;dlg.onconfirm = function() {
+#     #		          document.setLocation(a.getHref()); 
+#     #			}; return false;">Facebooker</a>
+#     link_to("Facebooker", "http://rubyforge.org/projects/facebooker", :confirm=>{:title=>"the page says:, :color=>"pink", :width=>"200px"})
+module ActionView
+  module Helpers
+    module UrlHelper
+      # Alters one and only one line of the Rails button_to.  See below.
+      def button_to_with_facebooker(name, options={}, html_options = {})
+        if !request_comes_from_facebook?
+           button_to_without_facebooker(name,options,html_options)
+        else
+          html_options = html_options.stringify_keys
+          convert_boolean_attributes!(html_options, %w( disabled ))
+
+          method_tag = ''
+          if (method = html_options.delete('method')) && %w{put delete}.include?(method.to_s)
+            method_tag = tag('input', :type => 'hidden', :name => '_method', :value => method.to_s)
+          end
+
+          form_method = method.to_s == 'get' ? 'get' : 'post'
+        
+          request_token_tag = ''
+          if form_method == 'post' && protect_against_forgery?
+            request_token_tag = tag(:input, :type => "hidden", :name => request_forgery_protection_token.to_s, :value => form_authenticity_token)
+          end
+        
+          if confirm = html_options.delete("confirm")
+            # this line is the only change => html_options["onclick"] = "return #{confirm_javascript_function(confirm)}"
+            html_options["onclick"] = "#{confirm_javascript_function(confirm, 'a.getForm().submit();')}return false;"
+          end
+
+          url = options.is_a?(String) ? options : self.url_for(options)
+          name ||= url
+ 
+          html_options.merge!("type" => "submit", "value" => name)
+
+          "<form method=\"#{form_method}\" action=\"#{escape_once url}\" class=\"button-to\"><div>" +
+            method_tag + tag("input", html_options) + request_token_tag + "</div></form>"
+        end
+      end
+
+      alias_method_chain :button_to, :facebooker
+
+      private
+
+	# Altered to throw an error on :popup and sanitize the javascript
+	# for Facebook.
+        def convert_options_to_javascript_with_facebooker!(html_options, url ='')
+          if !request_comes_from_facebook?
+            convert_options_to_javascript_without_facebooker!(html_options,url)
+   	  else
+            confirm, popup = html_options.delete("confirm"), html_options.delete("popup")
+
+            method, href = html_options.delete("method"), html_options['href']
+
+            html_options["onclick"] = case
+              when popup
+                raise ActionView::ActionViewError, "You can't use :popup"
+              when method # or maybe (confirm and method)
+                "#{method_javascript_function(method, url, href, confirm)}return false;"
+              when confirm # and only confirm
+                "#{confirm_javascript_function(confirm)}return false;"
+              else
+                html_options["onclick"]
+            end
+ 	  end
+        end
+
+	alias_method_chain :convert_options_to_javascript!, :facebooker
+
+
+	# Overrides a private method that link_to calls via convert_options_to_javascript! and
+	# also, button_to calls directly.  For Facebook, confirm can be a hash of options to 
+	# stylize the Facebook dialog.  Takes :title, :content, :style options.  See
+	# the Facebook page http://wiki.developers.facebook.com/index.php/FBJS for valid
+	# style formats like "color: 'black', background: 'white'" or like "'color','black'".
+	#
+	# == Examples ==
+	#
+	# link_to("Facebooker", "http://rubyforge.org/projects/facebooker", :confirm=>"Go to Facebooker?")
+	# link_to("Facebooker", "http://rubyforge.org/projects/facebooker", :confirm=>{:title=>"the page says:, :content=>"Go to Facebooker?"})
+	# link_to("Facebooker", "http://rubyforge.org/projects/facebooker", :confirm=>{:title=>"the page says:, :content=>"Go to Facebooker?", :color=>"pink"})
+        def confirm_javascript_function_with_facebooker(confirm, fun = nil)
+          if !request_comes_from_facebook?
+            confirm_javascript_function_without_facebooker(confirm)
+ 	  else
+  	    if(confirm.is_a?(Hash))
+                confirm_options = confirm.stringify_keys
+		title = confirm_options.delete("title") || "Please Confirm"
+		content = confirm_options.delete("content") || "Are you sure?"
+		style = confirm_options.empty? ? "" : convert_options_to_css(confirm_options)
+  	    else
+	      title,content,style = 'Please Confirm', confirm, ""
+	    end
+
+            "var dlg = new Dialog().showChoice('#{escape_javascript(title.to_s)}','#{escape_javascript(content.to_s)}').setStyle(#{style});"+
+	    "var a=this;dlg.onconfirm = function() { #{fun ? fun : 'document.setLocation(a.getHref());'} };"
+	  end
+        end
+
+	alias_method_chain :confirm_javascript_function, :facebooker
+
+	def convert_options_to_css(options)
+	  key_pair = options.shift
+	  style = "{#{key_pair[0]}: '#{key_pair[1]}'"
+	  for key in options.keys
+	    style << ", #{key}: '#{options[key]}'"
+	  end
+	  style << "}"
+	end
+
+	# Dynamically creates a form for link_to with method.  Calls confirm_javascript_function if and 
+	# only if (confirm && method) for link_to
+        def method_javascript_function_with_facebooker(method, url = '', href = nil, confirm = nil)
+          if !request_comes_from_facebook?
+            method_javascript_function_without_facebooker(method,url,href)
+ 	  else
+            action = (href && url.size > 0) ? "'#{url}'" : 'a.getHref()'
+            submit_function =
+              "var f = document.createElement('form'); f.setStyle('display','none'); " +
+              "a.getParentNode().appendChild(f); f.setMethod('POST'); f.setAction(#{action});"
+
+            unless method == :post
+              submit_function << "var m = document.createElement('input'); m.setType('hidden'); "
+              submit_function << "m.setName('_method'); m.setValue('#{method}'); f.appendChild(m);"
+            end
+
+            if protect_against_forgery?
+              submit_function << "var s = document.createElement('input'); s.setType('hidden'); "
+              submit_function << "s.setName('#{request_forgery_protection_token}'); s.setValue('#{escape_javascript form_authenticity_token}'); f.appendChild(s);"
+            end
+            submit_function << "f.submit();"
+
+	    if(confirm)
+	      confirm_javascript_function(confirm, submit_function)
+  	    else
+	      "var a=this;" + submit_function
+ 	    end
+          end
+	end
+
+	alias_method_chain :method_javascript_function, :facebooker
+
+    end
+  end
+end
+