rpbertp13-merb_facebooker 0.0.2.3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 YOUR NAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,15 @@
+merb_facebooker
+===============
+
+A plugin for Merb that hooks up the facebooker gem.  Currently it just mixes some good stuff into Merb::Controller... the helpers are missing along with the CGI extentions.  These should be easily ported from the rails plugin portion of facebooker... I just haven't needed it yet.
+
+Finnaly facebook comes to Merb :)
+
+Installation
+==============
+
+git clone git://github.com/vanpelt/merb_facebooker.git
+cd merb_facebooker
+rake gem
+cd ../your_merb_app
+gem install -i gems ../merb_facebooker/pkg/merb_facebooker-*.gem

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+PLUGIN = "merb_facebooker"
+NAME = "merb_facebooker"
+VERSION = "0.0.2"
+AUTHOR = "Chris Van Pelt"
+EMAIL = "vanpelt@doloreslabs.com"
+HOMEPAGE = "http://merb-plugins.rubyforge.org/merb_facebooker/"
+SUMMARY = "Merb plugin that makes rfacebooker work with merb..."
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.add_dependency('merb-core', '>= 0.9.4')
+  s.add_dependency('facebooker')
+  s.require_path = 'lib'
+  s.autorequire = PLUGIN
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{NAME}-#{VERSION}}
+end
+
+namespace :jruby do
+
+  desc "Run :package and install the resulting .gem with jruby"
+  task :install => :package do
+    sh %{#{SUDO} jruby -S gem install pkg/#{NAME}-#{Merb::VERSION}.gem --no-rdoc --no-ri}
+  end
+  
+end

data/TODO

@@ -0,0 +1,5 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/merb_facebooker.rb
+Add your Merb rake tasks to lib/merb_facebooker/merbtasks.rb

data/lib/merb_facebooker.rb

@@ -0,0 +1,35 @@
+#make sure we're running inside Merb
+require 'merb_facebooker/controller'
+require 'merb_facebooker/helpers'
+
+if defined?(Merb::Plugins)
+  dependency "facebooker"
+  dependency "merb-helpers"
+  
+  # Merb gives you a Merb::Plugins.config hash...feel free to put your stuff in your piece of it
+  facebook_config = "#{Merb.root}/config/facebooker.yml"
+  if File.exist?(facebook_config)
+    Merb::Plugins.config[:merb_facebooker] = YAML.load_file(facebook_config)[Merb.environment]
+    ENV['FACEBOOK_API_KEY'] = Merb::Plugins.config[:merb_facebooker]['api_key']
+    ENV['FACEBOOK_SECRET_KEY'] = Merb::Plugins.config[:merb_facebooker]['secret_key']
+    ENV['FACEBOOKER_RELATIVE_URL_ROOT'] = Merb::Plugins.config[:merb_facebooker]['canvas_page_name']
+    #ActionController::Base.asset_host = FACEBOOKER['callback_url']
+  end
+  
+  Merb.add_mime_type(:fbml,  :to_fbml,  %w[application/fbml text/fbml], :Encoding => "UTF-8")
+  Merb::Request.http_method_overrides.push(
+    proc { |c| c.params[:fb_sig_request_method] }
+  )
+  
+  Merb::BootLoader.before_app_loads do
+    Merb::Controller.send(:include, Facebooker::Merb::Controller) 
+    Merb::Controller.send(:include, Facebooker::Merb::Helpers)
+    # require code that must be loaded before the application
+  end
+  
+  Merb::BootLoader.after_app_loads do
+    # code that can be required after the application loads
+  end
+  
+  Merb::Plugins.add_rakefiles "merb_facebooker/merbtasks"
+end

data/lib/merb_facebooker/controller.rb

@@ -0,0 +1,259 @@
+module Facebooker
+  module Merb
+    module Controller      
+      def self.included(controller)
+        controller.extend(ClassMethods)
+        controller.before :set_fbml_format
+      end
+      
+      def absolute_url(*args)
+        options  = extract_options_from_args!(args) || {}
+        options[:protocol] ||= request.protocol
+        options[:host] = Facebooker.canvas_server_base + Facebooker.facebook_path_prefix
+        args << options
+        super(*args)
+      end
+      
+      #
+      # Just returns the @facebook_session instance variable
+      # 
+      def facebook_session
+        @facebook_session
+      end
+      
+      #
+      # Tries to secure the facebook_session, if it is not secured already, it tries to secure it 
+      # via the request parameter 'auth_token', if that doesn't work, it tries to use the parameters 
+      # from facebook (this could be in the request or via cookies [cookies in case of FBConnect]).
+      #
+      def set_facebook_session
+        session_set = session_already_secured? || secure_with_token! || secure_with_facebook_params!
+        if session_set
+          capture_facebook_friends_if_available! 
+          Session.current = facebook_session
+        end
+        session_set
+      end
+      
+      #
+      # initializes the @facebook_params instance using the method verified_facebook_params
+      #
+      def facebook_params
+        @facebook_params ||= verified_facebook_params
+      end      
+      
+      private
+      
+      #
+      # Ensures there is an existing facebook session, and if so, it ask if it is secured.
+      #
+      def session_already_secured?
+        (@facebook_session = session[:facebook_session]) && session[:facebook_session].secured?
+      end
+      
+      # 
+      # Use auth_token parameter for the creation of a facebook_session 
+      #
+      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
+      
+      #
+      # If the request is made from a facebook canvas, then it checks for the session key and the user
+      # from the facebook_params hash key
+      #
+      def secure_with_facebook_params!
+        debugger
+        return if !request_is_for_a_facebook_canvas? && !using_facebook_connect?
+        
+        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
+      
+      #
+      # Resets the facebook_session
+      #
+      def create_new_facebook_session_and_redirect!
+        session[:facebook_session] = new_facebook_session
+        throw :halt, redirect(session[:facebook_session].login_url) unless @installation_required 
+      end
+      
+      #
+      #  Facebooker Session Factory
+      #
+      def new_facebook_session
+        Facebooker::Session.create(Facebooker::Session.api_key, Facebooker::Session.secret_key)
+      end
+      
+      def capture_facebook_friends_if_available!
+        return unless request_is_for_a_facebook_canvas?
+        if friends = facebook_params['friends']
+          facebook_session.user.friends = friends.map do |friend_uid|
+            User.new(friend_uid, facebook_session)
+          end
+        end
+      end
+            
+      #
+      # Helper method (acts as ActiveSupport's blank? method)
+      #
+      def blank?(value)
+        (value == '0' || value.nil? || value == '')        
+      end
+
+      #
+      # Get all the parameters from facebook via the request or cookies...
+      # (Cookies have more presedence)
+      #
+      def verified_facebook_params
+        if !request.cookies[Facebooker::Session.api_key].blank?
+          facebook_sig_params = request.cookies.inject({}) do |collection, pair|
+            if pair.first =~ /^#{Facebooker::Session.api_key}_(.+)/
+              collection[$1] = pair.last
+            end
+            collection
+          end
+        else
+          # same ol...
+          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'])
+        end
+        
+        facebook_sig_params.inject(Mash.new) do |collection, pair| 
+          collection[pair.first] = facebook_parameter_conversions[pair.first].call(pair.last)
+          collection
+        end
+      end
+      
+      #
+      # Session timeout value
+      #
+      def earliest_valid_session
+        48.hours.ago
+      end
+      
+      
+      #
+      # Checks if the signature matches the hash made from the parameters (does not apply on FBConnect)
+      #
+      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
+      
+      #
+      # Parses the values from facebook_parameters
+      #
+      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
+      
+      #
+      # Overwrite of the redirect method, if it is to a canvas, then use an fbml_redirect_tag
+      #
+      def redirect(*args)
+        if request_is_for_a_facebook_canvas?
+          fbml_redirect_tag(*args)
+        else
+          super
+        end
+      end
+      
+      def fbml_redirect_tag(url)
+        puts url
+        "<fb:redirect url=\"#{url}\" />"
+      end
+      
+      def request_is_for_a_facebook_canvas?
+        !params['fb_sig_in_canvas'].blank?
+      end
+      
+      def using_facebook_connect?
+        !cookies[Facebooker::Session.api_key].blank?
+      end
+      
+      def application_is_installed?
+        facebook_params['added']
+      end
+      
+      def ensure_has_status_update(options = {})
+        has_extended_permission?("status_update") || application_needs_permission("status_update", options)
+      end
+      
+      def ensure_has_photo_upload(options = {})
+        has_extended_permission?("photo_upload") || application_needs_permission("photo_upload", options)
+      end
+      
+      def ensure_has_create_listing(options = {})
+        has_extended_permission?("create_listing") || application_needs_permission("create_listing", options)
+      end
+      
+      def ensure_has_rsvp_event(options = {})
+        has_extended_permission?("rsvp_event") || application_needs_permission("rsvp_event", options)
+      end
+      
+      def application_needs_permission(perm, options = {})
+        throw :halt, redirect(facebook_session.permission_url(perm, options))
+      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
+        authenticated_and_installed = ensure_authenticated_to_facebook && application_is_installed? 
+        application_is_not_installed_by_facebook_user unless authenticated_and_installed
+        authenticated_and_installed
+      end
+      
+      def application_is_not_installed_by_facebook_user
+        throw :halt, redirect(session[:facebook_session].install_url)
+      end
+      
+      def set_fbml_format
+        params[:format] = "fbml" if request_is_for_a_facebook_canvas?
+      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 :ensure_authenticated_to_facebook, options
+        end
+        
+        def ensure_application_is_installed_by_facebook_user(options = {})
+          before :ensure_application_is_installed_by_facebook_user, options
+        end
+      end
+    end
+  end
+end

data/lib/merb_facebooker/helpers.rb

@@ -0,0 +1,111 @@
+module Facebooker
+  module Merb
+    module Helpers
+      #const
+      VALID_FB_SHARED_PHOTO_SIZES = [:thumb, :small, :normal, :square]
+      VALID_FB_PHOTO_SIZES = VALID_FB_SHARED_PHOTO_SIZES      
+      VALID_FB_PROFILE_PIC_SIZES = VALID_FB_SHARED_PHOTO_SIZES
+      
+      VALID_FB_SHARED_ALIGN_VALUES = [:left, :right]
+      VALID_FB_PHOTO_ALIGN_VALUES = VALID_FB_SHARED_ALIGN_VALUES
+      VALID_FB_TAB_ITEM_ALIGN_VALUES = VALID_FB_SHARED_ALIGN_VALUES
+
+      FB_PHOTO_VALID_OPTION_KEYS = [:uid, :size, :align]
+      
+      # Create an fb:request-form without a selector
+      #
+      # The block passed to this tag is used as the content of the form
+      #
+      # The message param is the name sent to content_for that specifies the body of the message
+      #
+      # For example,
+      #
+      #  <% content_for("invite_message") do %>
+      #    This gets sent in the invite. <%= fb_req_choice("with a button!",new_poke_path) %>
+      #  <% end %>
+      #  <% fb_request_form("Poke","invite_message",create_poke_path) do %>
+      #    Send a poke to: <%= fb_friend_selector %> <br />
+      #    <%= fb_request_form_submit %>
+      #  <% end %>
+      
+      def fb_request_form(type ,message_param,url,&block)
+        content = capture(&block)
+        message = @_caught_content[message_param]
+        concat(tag("fb:request-form", content,
+                  {:action=>url,:method=>"post",:invite=>true,:type=>type,:content=>message}),
+              block.binding)
+      end
+      
+            
+      # Provides a FBML fb_profile_pic tag with the provided uid
+      # ==== Parameters
+      # user<OrmObject>:: The user object
+      # options<Hash>:: specify the users picture size
+      #
+      # === Options (options)
+      #  :size<Symbol>:: The size of the profile picture :small, :normal and :square
+      #
+      # ==== Returns
+      # String:: The fbml tag defaulting with thumb picture
+      #
+      # ==== Example
+      #    <%=  fb_profile_pic(@user) %>
+      def fb_profile_pic(user, options = {})
+        validate_fb_profile_pic_size(options)
+        options.merge!(:uid => cast_to_facebook_id(user))
+        self_closing_tag("fb:profile-pic", options)
+      end
+      
+      
+      
+      # Provides a FBML fb_photo tag with the a facebook photo
+      # ==== Parameters
+      # photo<Facebooker::Photo>:: The photo object Or Objec that respond to photo_id
+      # options<Hash>:: specify the pic size and 
+      #
+      # === Options (options)
+      #   <em> See: </em> http://wiki.developers.facebook.com/index.php/Fb:photo for complete list of options
+      #
+      # ==== Returns
+      # String:: The fbml photo tag defaulting with thumb picture
+      #
+      # ==== Example
+      #    <%=  fb_profile_pic(@user) %>
+      def fb_photo(photo, options = {})
+        # options.assert_valid_keys(FB_PHOTO_VALID_OPTION_KEYS) # TODO asserts
+        options.merge!(:pid => cast_to_photo_id(photo))
+        validate_fb_photo_size(options)
+        validate_fb_photo_align_value(options)
+        self_closing_tag("fb:photo", options)
+      end
+      
+      def cast_to_photo_id(object)
+        object.respond_to?(:photo_id) ? object.photo_id : object
+      end
+      
+      protected
+      def validate_fb_photo_align_value(options)
+        if options.has_key?(:align) && !VALID_FB_PHOTO_ALIGN_VALUES.include?(options[:align].to_sym)
+          raise(ArgumentError, "Unkown value for align: #{options[:align]}")
+        end
+      end
+      
+      def cast_to_facebook_id(object)
+        Facebooker::User.cast_to_facebook_id(object)
+      end
+      
+      def validate_fb_photo_size(options)
+        if options.has_key?(:size) && !VALID_FB_PHOTO_SIZES.include?(options[:size].to_sym)
+          raise(ArgumentError, "Unkown value for size: #{options[:size]}")
+        end
+      end
+      
+      def validate_fb_profile_pic_size(options)
+        if options.has_key?(:size) && !VALID_FB_PROFILE_PIC_SIZES.include?(options[:size].to_sym)
+          raise(ArgumentError, "Unkown value for size: #{options[:size]}")
+        end
+      end
+      
+    end # Helpers
+  end # Merb
+end # Facebooker

data/lib/merb_facebooker/merbtasks.rb

@@ -0,0 +1,49 @@
+namespace :facebooker do
+  desc "Create a basic facebooker.yml configuration file"
+  task :setup do   
+    facebook_config = File.join(Merb.root,"config","facebooker.yml")
+    unless File.exist?(facebook_config)
+      cp File.dirname(__FILE__) + '/../../templates/config/facebooker.yml', facebook_config 
+      puts "Configuration created in #{Merb.root}/config/facebooker.yml"
+    else
+      puts "#{Merb.root}/config/facebooker.yml already exists"
+    end
+  end
+  
+  namespace :tunnel do 
+    # Courtesy of Christopher Haupt
+    # http://www.BuildingWebApps.com
+    # http://www.LearningRails.com
+    desc "Create a reverse ssh tunnel from a public server to a private development server." 
+    task :start => [ :config ] do  
+      puts "Starting tunnel #{@public_host}:#{@public_port} to 0.0.0.0:#{@local_port}" 
+      exec "ssh -nNT -g -R *:#{@public_port}:0.0.0.0:#{@local_port} #{@public_host_username}@#{@public_host}" 
+    end 
+
+    desc "Create a reverse ssh tunnel in the background. Requires ssh keys to be setup." 
+    task :background_start => [ :config ] do  
+      puts "Starting tunnel #{@public_host}:#{@public_port} to 0.0.0.0:#{@local_port}" 
+      exec "ssh -nNT -g -R *:#{@public_port}:0.0.0.0:#{@local_port} #{@public_host_username}@#{@public_host} > /dev/null 2>&1 &" 
+    end 
+    
+    # Adapted from Evan Weaver: http://blog.evanweaver.com/articles/2007/07/13/developing-a-facebook-app-locally/ 
+    desc "Check if reverse tunnel is running"
+    task :status => [ :config ] do
+     if `ssh #{@public_host} -l #{@public_host_username} netstat -an | 
+         egrep "tcp.*:#{@public_port}.*LISTEN" | wc`.to_i > 0
+       puts "Seems ok"
+     else
+       puts "Down"
+     end
+    end
+
+    task :config do
+     facebook_config = File.dirname(__FILE__) + '/../../../../../config/facebooker.yml'
+     FACEBOOKER = YAML.load_file(facebook_config)[Merb.environment]
+     @public_host_username = FACEBOOKER['tunnel']['public_host_username'] 
+     @public_host = FACEBOOKER['tunnel']['public_host'] 
+     @public_port = FACEBOOKER['tunnel']['public_port'] 
+     @local_port = FACEBOOKER['tunnel']['local_port'] 
+    end
+  end
+end

data/spec/merb_facebooker_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+Merb::Router.prepare do |r|
+  r.match('/').to(:controller => 'facebook_helpers', :action =>'index')
+end
+
+class FacebookerHelpers < Merb::Controller
+  def index
+    "hi"
+  end
+end
+
+Merb::Config.use { |c|
+  c[:framework]           = {},
+  c[:session_store]       = 'none',
+  c[:exception_details]   = true
+}
+
+# ok lets start with the helpers and go from there
+describe "Controller With Facebooker Helpers" do
+  before(:all) do
+    @controller = FacebookerHelpers.new(fake_request)
+  end
+  
+  describe "calling fb_profile(@user, options) given user has facebook_id=1234" do
+    before(:all) do
+      @user = stub("User", :facebook_id => 1234)
+    end
+    
+    it "should be able to call" do
+      @controller.should respond_to(:fb_profile_pic)
+    end
+  
+    it "should equal <fb:profile-pic uid='1234' /> when calling with @user" do
+      @controller.fb_profile_pic(@user).should == "<fb:profile-pic uid=\"1234\"/>"
+    end
+  
+    it "should equal <fb:profile-pic uid='1234' size='small'/> when calling with @user, :size => :small" do
+      @controller.fb_profile_pic(@user, :size => :small).should == "<fb:profile-pic uid=\"1234\" size=\"small\"/>"
+    end
+  
+    it "should raise Argument Error is the incorrect size is given when calling @user, :size => :egg" do
+      lambda{@controller.fb_profile_pic(@user, :size => :egg)}.should raise_error
+    end
+  end
+  
+  
+  describe "calling fb_photo where given photo has an photo_id = 1234" do
+    before(:all) do
+      @photo = stub("Photo", :photo_id => 1234)
+    end
+    
+    it "should be able to call" do
+      @controller.should respond_to(:fb_photo)
+    end
+    
+    it "should equal <fb:photo pid=\"1234\" /> with parameter @photo" do
+      @photo.stub!(:photo_id).and_return(1234) # DONT ASK
+      @controller.fb_photo(@photo).should == "<fb:photo pid=\"1234\"/>"
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+# going to be specing for Merb so lets just do that shall we
+require 'rubygems'
+require 'merb-core'
+require 'merb_facebooker'
+require 'spec'
+
+Merb.start_environment(:testing => true, :adapter => 'runner', :environment => ENV['MERB_ENV'] || 'test')
+
+Spec::Runner.configure do |config|
+  config.include(Merb::Test::ViewHelper)
+  config.include(Merb::Test::RouteHelper)
+  config.include(Merb::Test::ControllerHelper)
+end

data/templates/config/facebooker.yml

@@ -0,0 +1,41 @@
+# The api key, secret key, and canvas page name are required to get started
+# Tunnel configuration is only needed if you are going to use the facebooker:tunnel Rake tasks
+# Your callback url in Facebook should be set to http://public_host:public_port
+# To develop for the new profile design, add the following key..
+# api: new
+# remove the key or set it to anything else to use the old facebook design.
+# This should only be necessary until the final version of the new profile is released.
+
+development:
+  api_key: 
+  secret_key: 
+  canvas_page_name:
+  callback_url:
+  pretty_errors: true
+  tunnel:
+    public_host_username: 
+    public_host: 
+    public_port: 4007
+    local_port: 3000
+
+test:
+  api_key: 
+  secret_key: 
+  canvas_page_name: 
+  callback_url:
+  tunnel:
+    public_host_username: 
+    public_host: 
+    public_port: 4007
+    local_port: 3000
+
+production:
+  api_key: 
+  secret_key: 
+  canvas_page_name: 
+  callback_url:  
+  tunnel:
+    public_host_username: 
+    public_host: 
+    public_port: 4007
+    local_port: 3000

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: rpbertp13-merb_facebooker
+version: !ruby/object:Gem::Version 
+  version: 0.0.2.3
+platform: ruby
+authors: 
+- Chris Van Pelt
+autorequire: merb_facebooker
+bindir: bin
+cert_chain: []
+
+date: 2009-05-16 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: merb-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mmangino-facebooker
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.10
+    version: 
+description: Merb plugin that makes rfacebooker work with merb...
+email: vanpelt@doloreslabs.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/merb_facebooker/controller.rb
+- lib/merb_facebooker/helpers.rb
+- lib/merb_facebooker/merbtasks.rb
+- lib/merb_facebooker.rb
+- spec/merb_facebooker_spec.rb
+- spec/spec_helper.rb
+- templates/config/facebooker.yml
+has_rdoc: true
+homepage: http://merb-plugins.rubyforge.org/merb_facebooker/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Merb plugin that makes rfacebooker work with merb...
+test_files: []
+