jet-facebooker 1.0.64

data/lib/facebooker/rails/helpers/fb_connect.rb

@@ -0,0 +1,161 @@
+module Facebooker
+  module Rails
+    module Helpers
+      module FbConnect
+        include Facebooker::Rails::Helpers::StreamPublish
+        def fb_connect_javascript_tag(options = {})
+          # accept both Rails and Facebook locale formatting, i.e. "en-US" and "en_US".
+          lang = "/#{options[:lang].to_s.gsub('-', '_')}" if options[:lang]
+          # dont use the javascript_include_tag helper since it adds a .js at the end
+          if request.ssl?
+            "<script src=\"https://ssl.connect.facebook.com/js/api_lib/v0.4/FeatureLoader.js.php#{lang}\" type=\"text/javascript\"></script>"
+          else
+            "<script src=\"http://static.ak.connect.facebook.com/js/api_lib/v0.4/FeatureLoader.js.php#{lang}\" type=\"text/javascript\"></script>"
+          end
+        end
+
+        #
+        # For information on the :app_settings argument see http://wiki.developers.facebook.com/index.php/JS_API_M_FB.Facebook.Init_2
+        # While it would be nice to treat :app_settings as a hash, some of the arguments do different things if they are a string vs a javascript function
+        # and Rails' Hash#to_json always quotes strings so there is no way to indicate when the value should be a javascript function.
+        # For this reason :app_settings needs to be a string that is valid JSON (including the {}'s).
+        #
+        def init_fb_connect(*required_features,&proc)
+          additions = ""
+          if block_given?
+            additions = capture(&proc)
+          end
+
+          # Yes, app_settings is set to a string of an empty JSON element. That's intentional.
+          options = {:js => :prototype, :app_settings => '{}'}
+
+          if required_features.last.is_a?(Hash)
+            options.merge!(required_features.pop.symbolize_keys)
+          end
+
+          if request.ssl?
+            init_string = "FB.init('#{Facebooker.api_key}','/xd_receiver_ssl.html', #{options[:app_settings]});"
+          else
+            init_string = "FB.init('#{Facebooker.api_key}','/xd_receiver.html', #{options[:app_settings]});"
+          end
+          unless required_features.blank?
+             init_string = <<-FBML
+             #{case options[:js]
+               when :jquery then "jQuery(document).ready("
+               when :mootools then "window.addEvent('domready',"
+               when :dojo then "dojo.addOnLoad("
+               else "Element.observe(window,'load',"
+               end} function() {
+                FB_RequireFeatures(#{required_features.to_json}, function() {
+                  #{init_string}
+                  #{additions}
+                });
+              });
+              FBML
+          end
+
+          # block_is_within_action_view? is rails 2.1.x and has been
+          # deprecated.  rails >= 2.2.x uses block_called_from_erb?
+          block_tester = respond_to?(:block_is_within_action_view?) ?
+            :block_is_within_action_view? : :block_called_from_erb?
+
+          if block_given? && send(block_tester, proc)
+            versioned_concat(javascript_tag(init_string),proc.binding)
+          else
+            javascript_tag init_string
+          end
+        end
+
+        #
+        # Render an <fb:login-button> element
+        #
+        # ==== Examples
+        #
+        #   <%= fb_login_button%>
+        #   => <fb:login-button></fb:login-button>
+        #
+        # Specifying a javascript callback
+        #
+        #   <%= fb_login_button 'update_something();'%>
+        #   => <fb:login-button onlogin='update_something();'></fb:login-button>
+        #
+        # Adding options <em>See:</em> http://wiki.developers.facebook.com/index.php/Fb:login-button
+        #
+        #   <%= fb_login_button 'update_something();', :size => :small, :background => :dark%>
+        #   => <fb:login-button background='dark' onlogin='update_something();' size='small'></fb:login-button>
+        #
+        # :text option allows you to set the text value of the
+        # button.  *A note!* This will only do what you expect it to do
+        # if you set :v => 2 as well.
+        #
+        #   <%= fb_login_button 'update_somethign();',
+        #        :text => 'Loginto Facebook', :v => 2 %>
+        #   => <fb:login-button v='2' onlogin='update_something();'>Login to Facebook</fb:login-button>
+        def fb_login_button(*args)
+
+          callback = args.first
+          options = args[1] || {}
+          options.merge!(:onlogin=>callback) if callback
+
+          text = options.delete(:text)
+
+          content_tag("fb:login-button",text, options)
+        end
+
+        #
+        # 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)
+          
+          content_tag("fb:login-button",text,options.merge(:onlogin=>js))
+        end
+
+        def fb_unconnected_friends_count
+          content_tag "fb:unconnected-friends-count",nil
+        end
+
+        def fb_logout_link(text,url,*args)
+          js = update_page do |page|
+            page.call "FB.Connect.logoutAndRedirect",url
+          end
+          link_to_function text, js, *args
+        end
+
+        def fb_bookmark_link(text,url,*args)
+          js = update_page do |page|
+            page.call "FB.Connect.showBookmarkDialog",url
+          end
+          link_to_function text, js, *args
+        end
+
+        def fb_user_action(action, user_message = nil, prompt = "", callback = nil)
+          defaulted_callback = callback || "null"
+          update_page do |page|
+            page.call("FB.Connect.showFeedDialog",action.template_id,action.data,action.target_ids,action.body_general,nil,page.literal("FB.RequireConnect.promptConnect"),page.literal(defaulted_callback),prompt,user_message.nil? ? nil : {:value=>user_message})
+          end
+        end
+        
+        def fb_connect_stream_publish(stream_post,user_message_prompt=nil,callback=nil,auto_publish=false,actor=nil)
+          stream_publish("FB.Connect.streamPublish",stream_post,user_message_prompt,callback,auto_publish,actor)
+        end
+
+      end
+    end
+  end
+end

data/lib/facebooker/rails/helpers/stream_publish.rb

@@ -0,0 +1,22 @@
+module Facebooker
+  module Rails
+    module Helpers
+      module StreamPublish
+        def stream_publish(js_method,stream_post,user_message_prompt=nil,callback=nil,auto_publish=false,actor=nil)
+           defaulted_callback = callback || "null"
+           update_page do |page|
+             page.call(js_method,
+                         stream_post.user_message,
+                         stream_post.attachment.to_hash,
+                         stream_post.action_links,
+                         Facebooker::User.cast_to_facebook_id(stream_post.target),
+                         user_message_prompt,
+                         page.literal(defaulted_callback),
+                         auto_publish,
+                         Facebooker::User.cast_to_facebook_id(actor))
+           end          
+        end
+      end
+    end
+  end
+end

data/lib/facebooker/rails/integration_session.rb

@@ -0,0 +1,38 @@
+require 'action_controller/integration'
+
+class Facebooker::Rails::IntegrationSession < ActionController::Integration::Session
+  include Facebooker::Rails::TestHelpers
+  attr_accessor :default_request_params, :canvas
+  
+  def process(method, path, parameters = nil, headers = nil)
+    if canvas
+      parameters = facebook_params(@default_request_params.merge(parameters || {}))
+    end
+    super method, path, parameters, headers
+  end
+  
+  def reset!
+    self.default_request_params = {:fb_sig_in_canvas => '1', :fb_sig_api_key => Facebooker::Session.api_key}.with_indifferent_access
+    self.canvas = true
+    super
+  end
+  
+  def get(path, parameters = nil, headers = nil)
+    if canvas
+      post path, (parameters || {}).merge('fb_sig_request_method' => 'GET'), headers
+    else
+      super path, parameters, headers
+    end
+  end
+  
+  %w(put delete).each do |method|
+    define_method method do |*args|
+      if canvas
+        path, parameters, headers = *args
+        post path, (parameters || {}).merge('_method' => method.upcase), headers
+      else
+        super *args
+      end
+    end
+  end
+end

data/lib/facebooker/rails/profile_publisher_extensions.rb

@@ -0,0 +1,42 @@
+module Facebooker
+  module Rails
+    module ProfilePublisherExtensions
+
+      ##
+      # returns true if Facebook is requesting the interface for a profile publisher
+      def wants_interface?
+        params[:method] == "publisher_getInterface"
+      end
+
+      ##
+      # render the interface for a publisher. 
+      # fbml is the content in string form. Use render_to_string to get the content from a template
+      # publish_enabled controlls whether the post form is active by default. If it isn't, you'll need to use fbjs to activate it
+      # comment_enabled controls whether to include a comment box
+      def render_publisher_interface(fbml,publish_enabled=true,comment_enabled=false)
+        render :json=>{:content=>{:fbml=>fbml,:publishEnabled=>publish_enabled,:commentEnabled=>comment_enabled},
+         :method=>"publisher_getInterface"}
+      end
+      
+      # render an error while publishing the template
+      # This can be used for validation errors
+      def render_publisher_error(title,body)
+        render :json=>{:errorCode=>1,:errorTitle=>title,:errorMessage=>body}.to_json
+      end
+
+      # render the response for a feed. This takes a user_action object like those returned from the Rails Publisher
+      # For instance, AttackPublisher.create_attack(@attack)
+      # The template must have been registered previously
+      def render_publisher_response(user_action)
+        render :json=>{:content=> {
+            :feed=>{
+              :template_id=>user_action.template_id,
+              :template_data=>user_action.data
+            }
+          },
+          :method=>"publisher_getFeedStory"
+        }
+      end
+    end
+  end
+end

data/lib/facebooker/rails/publisher.rb

@@ -0,0 +1,600 @@
+module Facebooker
+  module Rails
+    # ActionMailer like module for publishing Facbook messages
+    # 
+    # To use, create a subclass and define methods
+    # Each method should start by calling send_as to specify the type of message
+    # Valid options are  :email and :notification, :user_action, :profile, :ref, :publish_stream
+    # 
+    #
+    # Below is an example of each type
+    #
+    #   class TestPublisher < Facebooker::Rails::Publisher
+    #     # The new message templates are supported as well
+    #     # First, create a method that contains your templates:
+    #     # You may include multiple one line story templates and short story templates
+    #     # but only one full story template
+    #     #  Your most specific template should be first
+    #     #
+    #     # Before using, you must register your template by calling register. For this example
+    #     #  You would call TestPublisher.register_publish_action
+    #     #  Registering the template will store the template id returned from Facebook in the 
+    #     # facebook_templates table that is created when you create your first publisher
+    #     def publish_action_template
+    #       one_line_story_template "{*actor*} did stuff with {*friend*}"
+    #       one_line_story_template "{*actor*} did stuff"
+    #       short_story_template "{*actor*} has a title {*friend*}", render(:partial=>"short_body")
+    #       short_story_template "{*actor*} has a title", render(:partial=>"short_body")
+    #       full_story_template "{*actor*} has a title {*friend*}", render(:partial=>"full_body")    
+    #       action_links action_link("My text {*template_var*}","{*link_url*}")
+    #     end
+    #
+    #     # To send a registered template, you need to create a method to set the data
+    #     # The publisher will look up the template id from the facebook_templates table
+    #     def publish_action(f)
+    #       send_as :user_action
+    #       from f
+    #       story_size SHORT # or ONE_LINE or FULL
+    #       data :friend=>"Mike"
+    #     end
+    #   
+    #  
+    #     # Provide a from user to send a general notification
+    #     # if from is nil, this will send an announcement
+    #     def notification(to,f)
+    #       send_as :notification
+    #       recipients to
+    #       from f
+    #       fbml "Not"
+    #     end
+    #  
+    #     def email(to,f)
+    #       send_as :email
+    #       recipients to
+    #       from f
+    #       title "Email"
+    #       fbml 'text'
+    #       text fbml
+    #     end
+    #     # This will render the profile in /users/profile.fbml.erb
+    #     #   it will set @user to user_to_update in the template
+    #     #  The mobile profile will be rendered from the app/views/test_publisher/_mobile.erb
+    #     #   template
+    #     def profile_update(user_to_update,user_with_session_to_use)
+    #       send_as :profile
+    #       from user_with_session_to_use
+    #       recipients user_to_update
+    #       profile render(:file=>"users/profile.fbml.erb",:assigns=>{:user=>user_to_update})
+    #       profile_action "A string"
+    #       mobile_profile render(:partial=>"mobile",:assigns=>{:user=>user_to_update})
+    #   end
+    #
+    #     #  Update the given handle ref with the content from a
+    #     #   template
+    #     def ref_update(user)
+    #       send_as :ref
+    #       from user
+    #       fbml render(:file=>"users/profile",:assigns=>{:user=>user_to_update})
+    #       handle "a_ref_handle"
+    #   end
+    #
+    #     #  Publish a post into the stream on the user's Wall and News Feed.
+    #     def publish_stream(user_with_session_to_use, user_to_update, params)
+    #       send_as :publish_stream
+    #       from  user_with_session_to_use
+    #       target user_to_update
+    #       attachment params[:attachment]
+    #       message params[:message]
+    #       action_links params[:action_links]
+    #     end
+    #
+    #
+    # To send a message, use ActionMailer like semantics
+    #    TestPublisher.deliver_action(@user)
+    #
+    # For testing, you may want to create an instance of the underlying message without sending it
+    #  TestPublisher.create_action(@user)
+    # will create and return an instance of Facebooker::Feeds::Action
+    #
+    # Publisher makes many helpers available, including the linking and asset helpers
+    class Publisher
+
+      #story sizes from the Facebooker API
+      ONE_LINE=1
+      SHORT=2
+      FULL=4
+
+      def initialize
+        @from                 = nil
+        @full_story_template  = nil
+        @recipients           = nil
+        @action_links         = nil
+        @controller           = PublisherController.new(self)
+        @action_links         = nil
+      end
+
+      def self.default_url_options
+        {:host => Facebooker.canvas_server_base + Facebooker.facebook_path_prefix}
+      end
+
+      def default_url_options
+        self.class.default_url_options
+      end
+
+      # use facebook options everywhere
+      def request_comes_from_facebook?
+        true
+      end
+
+      class FacebookTemplate < ::ActiveRecord::Base
+        cattr_accessor :template_cache
+        self.template_cache = {}
+
+        def self.inspect(*args)
+          "FacebookTemplate"
+        end
+
+        def template_changed?(hash)
+          if respond_to?(:content_hash)
+            content_hash != hash 
+          else
+            false
+          end
+        end
+        
+        def deactivate
+          Facebooker::Session.create.deactivate_template_bundle_by_id(self.bundle_id)
+          return true
+        rescue Facebooker::Session::TemplateBundleInvalid => e
+          return false
+        end
+
+        
+        
+        class << self
+          
+          def register(klass,method)
+            publisher = setup_publisher(klass,method)            
+            template_id = Facebooker::Session.create.register_template_bundle(publisher.one_line_story_templates,publisher.short_story_templates,publisher.full_story_template,publisher.action_links)
+            template = find_or_initialize_by_template_name(template_name(klass,method))
+            template.deactivate if template.bundle_id  # deactivate old templates to avoid exceeding templates/app limit
+            template.bundle_id = template_id
+            template.content_hash = hashed_content(klass,method) if template.respond_to?(:content_hash)
+            template.save!
+            cache(klass,method,template)
+            template
+          end
+          
+          def for_class_and_method(klass,method)
+            find_cached(klass,method) 
+          end
+          def bundle_id_for_class_and_method(klass,method)
+            for_class_and_method(klass,method).bundle_id
+          end
+          
+          def cache(klass,method,template)
+            template_cache[template_name(klass,method)] = template
+          end
+          
+          def clear_cache!
+            self.template_cache = {}
+          end
+          
+          def find_cached(klass,method)
+            template_cache[template_name(klass,method)] || find_in_db(klass,method)
+          end
+          
+          def find_in_db(klass,method)
+            template = find_by_template_name(template_name(klass,method))
+            
+            if template.nil? || template.template_changed?(hashed_content(klass, method))
+              template = register(klass,method)
+            end
+            template
+          end
+          
+          def setup_publisher(klass,method)
+            publisher = klass.new
+            publisher.send method + '_template'
+            publisher
+          end
+          
+          def hashed_content(klass, method)
+            publisher = setup_publisher(klass,method)
+            # sort the Hash elements (in the short_story and full_story) before generating MD5
+            Digest::MD5.hexdigest [publisher.one_line_story_templates,
+               (publisher.short_story_templates and publisher.short_story_templates.collect{|ss| ss.to_a.sort_by{|e| e[0].to_s}}),
+               (publisher.full_story_template and publisher.full_story_template.to_a.sort_by{|e| e[0].to_s})
+               ].to_json
+          end
+
+          def template_name(klass,method)
+            "#{Facebooker.api_key}: #{klass.name}::#{method}"
+          end
+        end
+      end
+
+      class_inheritable_accessor :master_helper_module
+      attr_accessor :one_line_story_templates, :short_story_templates
+      attr_writer :action_links
+
+      cattr_accessor :skip_registry
+      self.skip_registry = false
+
+
+      class InvalidSender < StandardError; end
+      class UnknownBodyType < StandardError; end
+      class UnspecifiedBodyType < StandardError; end
+      class Email
+        attr_accessor :title
+        attr_accessor :text
+        attr_accessor :fbml
+      end
+  
+      class Notification
+        attr_accessor :fbml
+      end
+  
+      class Profile
+        attr_accessor :profile
+        attr_accessor :profile_action
+        attr_accessor :mobile_profile
+        attr_accessor :profile_main
+      end
+      class Ref
+        attr_accessor :handle
+        attr_accessor :fbml
+      end
+      class UserAction
+        attr_accessor :data
+        attr_reader   :target_ids
+        attr_accessor :body_general
+        attr_accessor :template_id
+        attr_accessor :template_name
+        attr_accessor :story_size
+
+        def target_ids=(val)
+          @target_ids = val.is_a?(Array) ? val.join(",") : val
+        end
+
+        def data_hash
+          data||{}
+        end
+      end
+
+      class PublishStream
+        attr_accessor :target
+        attr_accessor :attachment
+        attr_accessor :action_links
+        attr_accessor :message
+      end
+
+      cattr_accessor :ignore_errors
+      attr_accessor :_body
+
+      def recipients(*args)
+        if args.size==0
+          @recipients
+        else
+          @recipients=args.first
+        end
+      end
+      
+      def from(*args)
+        if args.size==0
+          @from
+        else
+          @from=args.first
+        end        
+      end
+
+
+      def send_as(option)
+        self._body=case option
+        when :action
+          Facebooker::Feed::Action.new
+        when :story
+          Facebooker::Feed::Story.new
+        when :templatized_action
+          Facebooker::Feed::TemplatizedAction.new
+        when :notification
+          Notification.new
+        when :email
+          Email.new
+        when :profile
+          Profile.new
+        when :ref
+          Ref.new
+        when :user_action
+          UserAction.new
+        when :publish_stream
+          StreamPost.new
+        else
+          raise UnknownBodyType.new("Unknown type to publish")
+        end
+      end
+      
+      def full_story_template(title=nil,body=nil,params={})
+        if title.nil?
+          @full_story_template
+        else
+          @full_story_template=params.merge(:template_title=>title, :template_body=>body)
+        end
+      end
+      
+      def one_line_story_template(str)
+        @one_line_story_templates ||= []
+        @one_line_story_templates << str
+      end
+
+      def short_story_template(title,body,params={})
+        @short_story_templates ||= []
+        @short_story_templates << params.merge(:template_title=>title, :template_body=>body)
+      end
+
+      def action_links(*links)
+        if self._body and self._body.respond_to?(:action_links)
+          self._body.send(:action_links,*links)
+        end
+        if links.blank?
+          @action_links
+        else
+          @action_links = links
+        end
+      end
+      
+      def method_missing(name,*args)
+        if args.size==1 and self._body.respond_to?("#{name}=")
+          self._body.send("#{name}=",*args)
+        elsif self._body.respond_to?(name)
+          self._body.send(name,*args)
+        else
+          super
+        end
+      end
+      
+      # work around the fact that facebook cares about the order of the keys in the hash
+      class ImageHolder
+        attr_accessor :src,:href
+        def initialize(src,href)
+          self.src=src
+          self.href=href
+        end
+
+        def ==(other)
+          self.src == other.src && self.href == other.href
+        end
+
+        def to_json(*args)
+          "{\"src\":#{src.to_json}, \"href\":#{href.to_json}}"
+        end
+      end
+      
+      def image(src,target)
+        ImageHolder.new(image_path(src),target.respond_to?(:to_str) ? target : url_for(target))
+      end
+           
+      def action_link(text,target)
+        {:text=>text, :href=>target}
+      end
+  
+      def requires_from_user?(from,body)
+        ! (announcement_notification?(from,body) or ref_update?(body) or profile_update?(body))
+      end
+      
+      def profile_update?(body)
+        body.is_a?(Profile)
+      end
+      
+      def ref_update?(body)
+        body.is_a?(Ref)
+      end
+  
+      def announcement_notification?(from,body)
+        from.nil? and body.is_a?(Notification)
+      end
+      
+      def send_message(method)
+        @recipients = @recipients.is_a?(Array) ? @recipients : [@recipients]
+        if from.nil? and @recipients.size==1 and requires_from_user?(from,_body)
+          @from = @recipients.first
+        end
+        # notifications can 
+        # omit the from address
+        raise InvalidSender.new("Sender must be a Facebooker::User") unless from.is_a?(Facebooker::User) || !requires_from_user?(from,_body)
+        case _body
+        when Facebooker::Feed::TemplatizedAction,Facebooker::Feed::Action
+          from.publish_action(_body)
+        when Facebooker::Feed::Story
+          @recipients.each {|r| r.publish_story(_body)}
+        when Notification
+          (from.nil? ? Facebooker::Session.create : from.session).send_notification(@recipients,_body.fbml)
+        when Email
+          from.session.send_email(@recipients, 
+                                             _body.title, 
+                                             _body.text, 
+                                             _body.fbml)
+        when Profile
+         # If recipient and from aren't the same person, create a new user object using the
+         # userid from recipient and the session from from
+         @from = Facebooker::User.new(Facebooker::User.cast_to_facebook_id(@recipients.first),Facebooker::Session.create) 
+         @from.set_profile_fbml(_body.profile, _body.mobile_profile, _body.profile_action, _body.profile_main)
+        when Ref
+          Facebooker::Session.create.server_cache.set_ref_handle(_body.handle,_body.fbml)
+        when UserAction
+          @from.session.publish_user_action(_body.template_id,_body.data_hash,_body.target_ids,_body.body_general,_body.story_size)
+        when Facebooker::StreamPost
+         @from.publish_to(_body.target, {:attachment => _body.attachment, :action_links => @action_links, :message => _body.message })
+        else
+          raise UnspecifiedBodyType.new("You must specify a valid send_as")
+        end
+      end
+
+      # nodoc
+      # needed for actionview
+      def logger
+        RAILS_DEFAULT_LOGGER
+      end
+
+      # nodoc
+      # delegate to action view. Set up assigns and render
+      def render(opts)
+        opts = opts.dup
+        body = opts.delete(:assigns) || {}
+        initialize_template_class(body.dup.merge(:controller=>self)).render(opts)
+      end
+
+
+      def initialize_template_class(assigns)
+        template_root = "#{RAILS_ROOT}/app/views"
+        controller_root = File.join(template_root,self.class.controller_path)
+        #only do this on Rails 2.1
+        if ActionController::Base.respond_to?(:append_view_path)
+          # only add the view path once
+          unless ActionController::Base.view_paths.include?(controller_root)
+            ActionController::Base.append_view_path(controller_root) 
+            ActionController::Base.append_view_path(controller_root+"/..") 
+          end
+          view_paths = ActionController::Base.view_paths
+        else
+          view_paths = [template_root, controller_root]
+        end
+        returning ActionView::Base.new(view_paths, assigns, self) do |template|
+          template.controller=self
+          template.extend(self.class.master_helper_module)
+          def template.request_comes_from_facebook?
+            true
+          end
+        end
+      end
+  
+      
+      self.master_helper_module = Module.new
+      self.master_helper_module.module_eval do
+        # url_helper delegates to @controller, 
+        # so we need to define that in the template
+        # we make it point to the publisher
+        include ActionView::Helpers::UrlHelper
+        include ActionView::Helpers::TextHelper
+        include ActionView::Helpers::TagHelper
+        include ActionView::Helpers::FormHelper
+        include ActionView::Helpers::FormTagHelper
+        include ActionView::Helpers::AssetTagHelper
+        include ActionView::Helpers::NumberHelper
+        include Facebooker::Rails::Helpers
+        
+        #define this for the publisher views
+        def protect_against_forgery?
+          @paf ||= ActionController::Base.new.send(:protect_against_forgery?)
+        end
+        
+        # url_for calls in publishers tend to want full paths
+        def url_for(options = {})
+          super(options.kind_of?(Hash) ? {:only_path => false}.update(options) : options)
+        end
+      end
+      ActionController::Routing::Routes.named_routes.install(self.master_helper_module)
+      include self.master_helper_module
+      class <<self
+
+        def register_all_templates_on_all_applications
+          Facebooker.with_all_applications do
+            puts "Registering templates for #{Facebooker.api_key}"
+            register_all_templates
+          end
+        end
+        
+        def register_all_templates
+          all_templates = instance_methods.grep(/_template$/) - %w(short_story_template full_story_template one_line_story_template) 
+          all_templates.each do |template|
+            template_name=template.sub(/_template$/,"")
+            puts "Registering #{template_name}"
+            send("register_"+template_name)
+          end
+        end
+        
+        def unregister_inactive_templates
+          session = Facebooker::Session.create
+          active_template_ids = FacebookTemplate.all.map(&:bundle_id)
+          all_template_ids = session.active_template_bundles.map {|t| t["template_bundle_id"]}
+          (all_template_ids - active_template_ids).each do |template_bundle_id|
+            session.deactivate_template_bundle_by_id(template_bundle_id)
+          end
+        end
+        
+        def method_missing(name,*args)
+          should_send = false
+          method = ''
+          if md = /^create_(.*)$/.match(name.to_s)
+            method = md[1]
+          elsif md = /^deliver_(.*)$/.match(name.to_s)
+            method = md[1]
+            should_send = true            
+          elsif md = /^register_(.*)$/.match(name.to_s)
+            return FacebookTemplate.register(self, md[1])
+          else
+            super
+          end
+      
+          #now create the item
+          (publisher=new).send(method,*args)
+          case publisher._body
+          when UserAction
+            publisher._body.template_name = method
+            publisher._body.template_id ||= FacebookTemplate.bundle_id_for_class_and_method(self,method)
+          end
+          
+          should_send ? publisher.send_message(method) : publisher._body
+        end
+        
+        def controller_path
+          self.to_s.underscore
+        end
+        
+        def helper(*args)
+          args.each do |arg|
+            case arg
+            when Symbol,String
+              add_template_helper("#{arg.to_s.camelcase}Helper".constantize)
+            when Module
+              add_template_helper(arg)
+            end
+          end
+        end
+
+        def add_template_helper(helper_module) #:nodoc:
+          master_helper_module.send :include,helper_module
+          include master_helper_module
+        end
+
+
+        def inherited(child)
+          super
+          child.master_helper_module=Module.new
+          child.master_helper_module.__send__(:include,self.master_helper_module)
+          child.send(:include, child.master_helper_module)
+          FacebookTemplate.clear_cache!
+        end
+
+      end
+      class PublisherController
+        include Facebooker::Rails::Publisher.master_helper_module
+        include ActionController::UrlWriter
+        
+        def initialize(source)
+          self.class.url_option_source = source
+        end
+
+        class << self
+          attr_accessor :url_option_source
+          alias :old_default_url_options :default_url_options
+          def default_url_options(*args)
+            url_option_source.default_url_options(*args)
+          end
+        end
+
+      end
+
+    end
+  end
+end