upstream-simple_facebook_connect 0.0.1

data/generators/simple_facebook_connect_migration/simple_facebook_connect_migration_generator.rb

@@ -0,0 +1,13 @@
+class SimpleFacebookConnectMigrationGenerator < Rails::Generator::Base 
+  
+  def manifest
+    record do |r|
+      r.migration_template 'migration.rb', "db/migrate"
+    end
+  end
+  
+  def file_name
+    "add_facebook_connect" 
+  end
+  
+end

data/generators/simple_facebook_connect_migration/templates/migration.rb

@@ -0,0 +1,17 @@
+class AddFacebookConnect < ActiveRecord::Migration
+  def self.up
+    add_column :users, :fb_uid, :integer
+    add_column :users, :email_hash, :string
+    
+    add_index :users, :fb_uid
+    add_index :users, :email_hash
+  end
+
+  def self.down
+    remove_index :users, :fb_uid
+    remove_index :users, :email_hash
+
+    remove_column :users, :email_hash
+    remove_column :users, :fb_uid
+  end
+end

data/init.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/lib/simple_facebook_connect'
+
+config_file = Rails.root + 'config/simple_facebook_connect.yml'
+
+unless File.exist?(config_file)
+  File.open(config_file, 'w') do |f|
+    f << <<-CONF
+test:
+  api_key:
+  secret_key: 
+
+development:
+  api_key:
+  secret_key: 
+
+production:
+  api_key:
+  secret_key: 
+  
+CONF
+  end
+  
+  puts "Created the facebook simple connect configuration in #{config_file}. Please enter your facebook API and secret keys there."
+  exit(1)
+end
+
+config = YAML::load(File.read(config_file))[Rails.env]
+
+SimpleFacebookConnect.api_key = config['api_key']
+SimpleFacebookConnect.secret_key = config['secret_key']
+
+ApplicationController.send(:include, SimpleFacebookConnect::ControllerExtension)
+User.send(:include, SimpleFacebookConnect::UserExtension)
+
+require 'simple_facebook_connect/extensions/routes'

data/lib/simple_facebook_connect.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH << File.dirname(__FILE__)
+
+require 'simple_facebook_connect/parser'
+require 'simple_facebook_connect/service'
+require 'simple_facebook_connect/session'
+require 'simple_facebook_connect/user'
+require 'simple_facebook_connect/user_extension'
+require 'simple_facebook_connect/controller_extension'
+
+module SimpleFacebookConnect
+  class << self
+    attr_accessor :api_key, :secret_key
+  end
+end

data/lib/simple_facebook_connect/controller_extension.rb

@@ -0,0 +1,11 @@
+module SimpleFacebookConnect
+  module ControllerExtension
+    def facebook_session
+      session[:facebook_session]
+    end
+
+    def facebook_user
+      (session[:facebook_session] && session[:facebook_session].session_key) ? session[:facebook_session].user : nil
+    end
+  end
+end

data/lib/simple_facebook_connect/extensions/routes.rb

@@ -0,0 +1,13 @@
+# without this hack people can't override our routes when subclassing controllers in the app. trick stolen from clearance.
+class ActionController::Routing::RouteSet
+  def load_routes_with_simple_facebook_connect!
+    lib_path = File.dirname(__FILE__)
+    routes = File.join(lib_path, *%w[.. .. .. config simple_facebook_connect_routes.rb])
+    unless configuration_files.include?(routes)
+      add_configuration_file(routes)
+    end
+    load_routes_without_simple_facebook_connect!
+  end
+
+  alias_method_chain :load_routes!, :simple_facebook_connect
+end

data/lib/simple_facebook_connect/parser.rb

@@ -0,0 +1,161 @@
+require 'rexml/document'
+
+module SimpleFacebookConnect
+  
+  class Parser
+    
+    module REXMLElementExtensions
+      def text_value
+        self.children.first.to_s.strip
+      end
+    end
+  
+    ::REXML::Element.__send__(:include, REXMLElementExtensions)
+  
+    def self.parse(method, data)
+      Errors.process(data)
+      parser = PARSERS[method]
+      parser.process(
+        data
+      )
+    end
+  
+    def self.array_of(response_element, element_name)
+      values_to_return = []
+      response_element.elements.each(element_name) do |element|
+        values_to_return << yield(element)
+      end
+      values_to_return
+    end
+  
+    def self.array_of_text_values(response_element, element_name)
+      array_of(response_element, element_name) do |element|
+        element.text_value
+      end
+    end
+
+    def self.array_of_hashes(response_element, element_name)
+      array_of(response_element, element_name) do |element|
+        hashinate(element)
+      end
+    end
+  
+    def self.element(name, data)
+      data = data.body rescue data # either data or an HTTP response
+      doc = REXML::Document.new(data)
+      doc.elements.each(name) do |element|
+        return element
+      end
+      raise "Element #{name} not found in #{data}"
+    end
+  
+    def self.hash_or_value_for(element)
+      if element.children.size == 1 && element.children.first.kind_of?(REXML::Text)
+        element.text_value
+      else
+        hashinate(element)
+      end
+    end
+  
+    def self.hashinate(response_element)
+      response_element.children.reject{|c| c.kind_of? REXML::Text}.inject({}) do |hash, child|
+        # If the node hasn't any child, and is not a list, we want empty strings, not empty hashes,
+        #   except if attributes['nil'] == true
+        hash[child.name] = 
+        if (child.attributes['nil'] == 'true')
+          nil 
+        elsif (child.children.size == 1 && child.children.first.kind_of?(REXML::Text)) || (child.children.size == 0 && child.attributes['list'] != 'true')
+          anonymous_field_from(child, hash) || child.text_value
+        elsif child.attributes['list'] == 'true'
+          child.children.reject{|c| c.kind_of? REXML::Text}.map { |subchild| hash_or_value_for(subchild)}    
+        else
+          child.children.reject{|c| c.kind_of? REXML::Text}.inject({}) do |subhash, subchild|
+            subhash[subchild.name] = hash_or_value_for(subchild)
+            subhash
+          end
+        end #if (child.attributes)
+        hash
+      end #do |hash, child|      
+    end
+  
+    def self.booleanize(response)
+      response == "1" ? true : false
+    end
+  
+    def self.anonymous_field_from(child, hash)
+      if child.name == 'anon'
+        (hash[child.name] || []) << child.text_value
+      end
+    end
+  
+    class RevokeAuthorization < self
+      def self.process(data)
+        booleanize(data)
+      end
+    end
+
+    class CreateToken < self
+      def self.process(data)
+        element('auth_createToken_response', data).text_value
+      end
+    end
+
+    class RegisterUsers < self
+      def self.process(data)
+        array_of_text_values(element("connect_registerUsers_response", data), "connect_registerUsers_response_elt")
+      end
+    end
+
+    class GetSession < self
+      def self.process(data)      
+        hashinate(element('auth_getSession_response', data))
+      end
+    end
+
+    class UserInfo < self
+      def self.process(data)
+        array_of_hashes(element('users_getInfo_response', data), 'user')
+      end
+    end
+
+    class UserStandardInfo < self
+      def self.process(data)
+        array_of_hashes(element('users_getStandardInfo_response', data), 'standard_user_info')
+      end
+    end
+
+    class GetLoggedInUser < self
+      def self.process(data)
+        Integer(element('users_getLoggedInUser_response', data).text_value)
+      end
+    end
+
+    class ProfileInfo < self
+      def self.process(data)
+        hashinate(element('profile_getInfo_response info_fields', data))
+      end
+    end
+
+    class Errors < self
+      def self.process(data)
+        response_element = element('error_response', data) rescue nil
+        if response_element
+          hash = hashinate(response_element)
+          raise StandardError, hash['error_msg']
+        end
+      end
+    end
+  
+  
+    PARSERS = {
+      'facebook.auth.revokeAuthorization' => RevokeAuthorization,
+      'facebook.auth.createToken' => CreateToken,
+      'facebook.auth.getSession' => GetSession,
+      'facebook.connect.registerUsers' => RegisterUsers,
+      'facebook.users.getInfo' => UserInfo,
+      'facebook.users.getStandardInfo' => UserStandardInfo,
+      'facebook.profile.getInfo' => ProfileInfo
+    }
+
+  end  
+end

data/lib/simple_facebook_connect/service.rb

@@ -0,0 +1,34 @@
+require 'net/http'
+
+module SimpleFacebookConnect
+  
+  class Service
+    def initialize(api_base, api_path, api_key)
+      @api_base = api_base
+      @api_path = api_path
+      @api_key = api_key
+    end
+  
+    def post(params)
+      attempt = 0
+      Parser.parse(params[:method], post_form(url,params) )
+    rescue Errno::ECONNRESET, EOFError
+      if attempt == 0
+        attempt += 1
+        retry
+      end
+    end
+  
+    def post_form(url,params)
+      Net::HTTP.post_form(url, params.stringify_keys)
+    end
+  
+    private
+    def url(base = nil)
+      base ||= @api_base
+      URI.parse('http://'+ base + @api_path)
+    end
+  
+  
+  end
+end

data/lib/simple_facebook_connect/session.rb

@@ -0,0 +1,73 @@
+module SimpleFacebookConnect
+  
+  class Session
+    API_SERVER_BASE_URL       = "api.facebook.com"
+    API_PATH_REST             = "/restserver.php"
+    WWW_SERVER_BASE_URL       = "www.facebook.com"
+    WWW_PATH_LOGIN            = "/login.php"
+
+    attr_accessor :auth_token
+    attr_reader :session_key
+
+
+    def initialize(api_key, secret_key)
+      @api_key        = api_key
+      @secret_key     = secret_key
+      @session_key    = nil
+      @uid            = nil
+      @auth_token     = nil
+      @secret_from_session = nil
+      @expires        = nil
+    end
+  
+    def login_url(options={})
+      "http://#{WWW_SERVER_BASE_URL}#{WWW_PATH_LOGIN}?api_key=#{@api_key}&v=1.0"
+    end
+  
+
+    def secure!
+      response = post 'facebook.auth.getSession', :auth_token => auth_token
+      @session_key = response['session_key']
+      @uid = response['uid'].to_i
+      @expires = response['expires'].to_i
+      @secret_from_session = response['secret']
+    end    
+
+    def user
+      @user ||= User.new(uid, self)
+    end
+  
+    def post(method, params = {}, use_session_key = true, &proc)
+      add_facebook_params(params, method)
+      use_session_key && @session_key && params[:session_key] ||= @session_key
+      final_params = params.merge(:sig => signature_for(params))
+      result = service.post(final_params)
+      result = yield result if block_given?
+      result
+    end
+
+    private
+    def add_facebook_params(hash, method)
+      hash[:method] = method
+      hash[:api_key] = @api_key
+      hash[:call_id] = Time.now.to_f.to_s unless method == 'facebook.auth.getSession'
+      hash[:v] = "1.0"
+    end
+
+    def service
+      @service ||= Service.new(API_SERVER_BASE_URL, API_PATH_REST, @api_key)      
+    end
+
+    def uid
+      @uid || (secure!; @uid)
+    end
+
+    def signature_for(params)
+      raw_string = params.inject([]) do |collection, pair|
+        collection << pair.join("=")
+        collection
+      end.sort.join
+      Digest::MD5.hexdigest([raw_string, @secret_key].join)
+    end
+  end
+end

data/lib/simple_facebook_connect/user.rb

@@ -0,0 +1,26 @@
+module SimpleFacebookConnect
+  
+  class User
+
+    FIELDS = [:uid, :hometown_location, :first_name, :last_name, :current_location, :pic, :locale, :email_hashes]
+    attr_reader(*FIELDS)
+  
+    def initialize(uid, session)
+      @uid = uid
+      populate(session)
+    end
+
+    def populate(session)
+      session.post('facebook.users.getInfo', :fields => coma_seperated_fields, :uids => uid) do |response|
+        FIELDS.each do |field|
+          instance_variable_set(:"@#{field}", response.first[field.to_s])
+        end
+      end
+    end
+  
+    def coma_seperated_fields
+      FIELDS.join(',')
+    end
+  
+  end
+end

data/lib/simple_facebook_connect/user_extension.rb

@@ -0,0 +1,21 @@
+require 'zlib'
+require 'digest/md5'
+
+module SimpleFacebookConnect
+  module UserExtension
+    
+    def self.included(base)
+      base.class_eval do
+        before_save :build_email_hash, :if => :email_changed?
+      end
+    end
+  
+    private
+
+    def build_email_hash
+      str = email.strip.downcase
+      self.email_hash = "#{Zlib.crc32(str)}_#{Digest::MD5.hexdigest(str)}"
+    end
+
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../init'

data/simple_facebook_connect.gemspec

@@ -0,0 +1,71 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{simple_facebook_connect}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alexander Lang", "Frank Pr\303\266\303\237dorf"]
+  s.date = %q{2009-07-15}
+  s.email = %q{alex@upstream-berlin.com}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "app/controllers/simple_facebook_connect/connect_controller.rb",
+     "app/views/shared/_facebook_connect_button.html.erb",
+     "config/simple_facebook_connect_routes.rb",
+     "generators/simple_facebook_connect_features/simple_facebook_connect_features_generator.rb",
+     "generators/simple_facebook_connect_features/templates/facebook_auth_getsession.xml",
+     "generators/simple_facebook_connect_features/templates/facebook_connect.feature",
+     "generators/simple_facebook_connect_features/templates/facebook_connect_steps.rb",
+     "generators/simple_facebook_connect_features/templates/facebook_connect_stubs.rb",
+     "generators/simple_facebook_connect_features/templates/facebook_users_getinfo.xml",
+     "generators/simple_facebook_connect_migration/simple_facebook_connect_migration_generator.rb",
+     "generators/simple_facebook_connect_migration/templates/migration.rb",
+     "init.rb",
+     "lib/simple_facebook_connect.rb",
+     "lib/simple_facebook_connect/controller_extension.rb",
+     "lib/simple_facebook_connect/extensions/routes.rb",
+     "lib/simple_facebook_connect/parser.rb",
+     "lib/simple_facebook_connect/service.rb",
+     "lib/simple_facebook_connect/session.rb",
+     "lib/simple_facebook_connect/user.rb",
+     "lib/simple_facebook_connect/user_extension.rb",
+     "rails/init.rb",
+     "simple_facebook_connect.gemspec",
+     "spec/fixtures/facebook.auth.getSession/default.xml",
+     "spec/fixtures/facebook.users.getInfo/default.xml",
+     "spec/lib/simple_facebook_connect/parser_spec.rb",
+     "spec/lib/simple_facebook_connect/user_extension_spec.rb",
+     "spec/lib/simple_facebook_connect/user_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/upstream/simple_facebook_connect}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{This plugin adds the ability to sign in/sign up using facebook connect to your Rails application.}
+  s.test_files = [
+    "spec/lib/simple_facebook_connect/parser_spec.rb",
+     "spec/lib/simple_facebook_connect/user_extension_spec.rb",
+     "spec/lib/simple_facebook_connect/user_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end