twitter-auth-with-mongo-mapper 0.0.9

data/generators/twitter_auth/templates/twitter_auth.yml

@@ -0,0 +1,47 @@
+<% if options[:oauth] -%>
+development:
+  strategy: oauth
+  oauth_consumer_key: devkey
+  oauth_consumer_secret: devsecret
+  base_url: "https://twitter.com"
+  authorize_path: "/oauth/authenticate"
+  api_timeout: 10
+  remember_for: 14 # days
+  oauth_callback: "http://localhost:3000/oauth_callback"
+test:
+  strategy: oauth
+  oauth_consumer_key: testkey
+  oauth_consumer_secret: testsecret
+  base_url: "https://twitter.com"
+  authorize_path: "/oauth/authenticate"
+  api_timeout: 10
+  remember_for: 14 # days
+  oauth_callback: "http://localhost:3000/oauth_callback"
+production:
+  strategy: oauth
+  oauth_consumer_key: prodkey
+  oauth_consumer_secret: prodsecret 
+  authorize_path: "/oauth/authenticate"
+  base_url: "https://twitter.com"
+  api_timeout: 10
+  remember_for: 14 # days
+<% else -%>
+development:
+  strategy: basic
+  api_timeout: 10
+  base_url: "https://twitter.com"
+  # randomly generated key for encrypting Twitter passwords
+  encryption_key: "<%= key = ActiveSupport::SecureRandom.hex(12) %>"
+  remember_for: 14 # days
+test:
+  strategy: basic
+  api_timeout: 10
+  base_url: "https://twitter.com"
+  encryption_key: "<%= key %>"
+  remember_for: 14 # days
+production:
+  strategy: basic
+  api_timeout: 10
+  encryption_key: "<%= key %>"
+  remember_for: 14 # days
+<% end %>

data/generators/twitter_auth/templates/user.rb

@@ -0,0 +1,5 @@
+class User < TwitterAuth::GenericUser
+  # Extend and define your user model as you see fit.
+  # All of the authentication logic is handled by the 
+  # parent TwitterAuth::GenericUser class.
+end

data/generators/twitter_auth/twitter_auth_generator.rb

@@ -0,0 +1,34 @@
+class TwitterAuthGenerator < Rails::Generator::Base
+  default_options :oauth => true, :basic => false
+
+  def manifest
+    record do |m|
+      m.class_collisions 'User'
+
+      m.migration_template 'migration.rb', 'db/migrate', :migration_file_name => 'twitter_auth_migration'
+      m.template 'user.rb', File.join('app','models','user.rb')
+      m.template 'twitter_auth.yml', File.join('config','twitter_auth.yml')
+    end
+  end
+
+  protected
+
+  def banner
+    "Usage: #{$0} twitter_auth"
+  end
+
+  def add_options!(opt)
+    opt.separator ''
+    opt.separator 'Options:'
+    
+    opt.on('-O', '--oauth', 'Use the OAuth authentication strategy to connect to Twitter. (default)') { |v| 
+      options[:oauth] = v
+      options[:basic] = !v
+    }
+
+    opt.on('-B', '--basic', 'Use the HTTP Basic authentication strategy to connect to Twitter.') { |v| 
+      options[:basic] = v
+      options[:oauth] = !v
+    }
+  end
+end

data/lib/twitter_auth.rb

@@ -0,0 +1,100 @@
+module TwitterAuth
+  class Error < StandardError; end
+
+  def self.config(environment=RAILS_ENV)
+    @config ||= {}
+    @config[environment] ||= YAML.load(File.open(RAILS_ROOT + '/config/twitter_auth.yml').read)[environment]
+  end
+
+  def self.base_url
+    config['base_url'] || 'https://twitter.com'    
+  end
+
+  def self.path_prefix
+    URI.parse(base_url).path
+  end
+
+  def self.api_timeout
+    config['api_timeout'] || 10
+  end
+
+  def self.encryption_key
+    raise TwitterAuth::Cryptify::Error, 'You must specify an encryption_key in config/twitter_auth.yml' if config['encryption_key'].blank?
+    config['encryption_key'] 
+  end
+
+  def self.oauth_callback?
+    config.key?('oauth_callback')
+  end
+
+  def self.oauth_callback
+    config['oauth_callback']
+  end
+
+  def self.remember_for
+    (config['remember_for'] || 14).to_i
+  end
+
+  # The authentication strategy employed by this
+  # application. Set in +config/twitter.yml+ as
+  # strategy; valid options are oauth or basic.
+  def self.strategy
+    strat = config['strategy']
+    raise ArgumentError, 'Invalid TwitterAuth Strategy: Valid strategies are oauth and basic.' unless %w(oauth basic).include?(strat)
+    strat.to_sym
+  rescue Errno::ENOENT
+    :oauth
+  end
+
+  def self.oauth?
+    strategy == :oauth
+  end
+
+  def self.basic?
+    strategy == :basic
+  end
+  
+  # The OAuth consumer used by TwitterAuth for authentication. The consumer key and secret are set in your application's +config/twitter.yml+
+  def self.consumer
+    options = {:site => TwitterAuth.base_url}
+    [ :authorize_path, 
+      :request_token_path,
+      :access_token_path,
+      :scheme,
+      :signature_method ].each do |oauth_option|
+      options[oauth_option] = TwitterAuth.config[oauth_option.to_s] if TwitterAuth.config[oauth_option.to_s]
+    end
+
+    OAuth::Consumer.new(
+      config['oauth_consumer_key'],          
+      config['oauth_consumer_secret'],
+      options 
+    )
+  end
+
+  def self.net
+    uri = URI.parse(TwitterAuth.base_url)
+    net = Net::HTTP.new(uri.host, uri.port)
+    net.use_ssl = uri.scheme == 'https'
+    net.read_timeout = TwitterAuth.api_timeout
+    net
+  end
+
+  def self.authorize_path
+    config['authorize_path'] || '/oauth/authorize'
+  end
+end
+
+require 'twitter_auth/controller_extensions'
+require 'twitter_auth/cryptify'
+require 'twitter_auth/dispatcher/oauth'
+require 'twitter_auth/dispatcher/basic'
+require 'twitter_auth/dispatcher/shared'
+
+module TwitterAuth
+  module Dispatcher
+    class Error < StandardError; end
+    class Unauthorized < Error; end
+  end
+end
+

data/lib/twitter_auth/controller_extensions.rb

@@ -0,0 +1,82 @@
+module TwitterAuth
+  # These methods borrow HEAVILY from Rick Olsen's
+  # Restful Authentication. All cleverness props
+  # go to him, not me.
+  module ControllerExtensions
+    def self.included(base)
+      base.send :helper_method, :current_user, :logged_in?, :authorized?
+    end
+
+    protected
+
+    def authentication_failed(message, destination='/')
+      flash[:error] = message
+      redirect_to destination
+    end
+
+    def authentication_succeeded(message = 'You have logged in successfully.', destination = '/')
+      flash[:notice] = message
+      redirect_back_or_default destination
+    end
+    
+    def onboard_user(message = 'Welcome to Vowch!', destination='/')
+      flash[:notice] = message
+      redirect_back_or_default destination
+    end
+
+    def current_user
+      @current_user ||= 
+        if session[:user_id]
+          User.find_by_id(session[:user_id])
+        elsif cookies[:remember_token]
+          begin
+            User.from_remember_token(cookies[:remember_token])
+          rescue
+            cookies.delete(:remember_token)
+            false   
+          end
+        else
+          false
+        end
+    end
+
+    def current_user=(new_user)
+      session[:user_id] = new_user.id
+      @current_user = new_user
+    end
+
+    def authorized?
+      !!current_user
+    end
+
+    def login_required
+      authorized? || access_denied 
+    end
+
+    def access_denied
+      store_location
+      redirect_to login_path
+    end
+
+    def store_location
+      session[:return_to] = request.request_uri
+    end
+
+    def redirect_back_or_default(default)
+      redirect_to(session[:return_to] || default)
+      session[:return_to] = nil
+    end
+
+    def logged_in?
+      !!current_user
+    end
+
+    def logout_keeping_session!
+      session[:user_id] = nil
+      @current_user = nil
+      cookies.delete(:remember_token)
+    end
+  end
+end
+
+ActionController::Base.send(:include, TwitterAuth::ControllerExtensions)

data/lib/twitter_auth/cryptify.rb

@@ -0,0 +1,31 @@
+module TwitterAuth
+  module Cryptify
+    class Error < StandardError; end
+    
+    def self.encrypt(data)
+      salt = generate_salt
+      key = EzCrypto::Key.with_password(TwitterAuth.encryption_key, salt)
+      {:encrypted_data => key.encrypt64(data), :salt => salt}
+    end
+ 
+    def self.decrypt(encrypted_data_or_hash, salt=nil)
+      case encrypted_data_or_hash
+      when String
+        encrypted_data = encrypted_data_or_hash
+        raise ArgumentError, 'Must provide a salt to decrypt.' unless salt
+      when Hash
+        encrypted_data = encrypted_data_or_hash[:encrypted_data]
+        salt = encrypted_data_or_hash[:salt]
+      else
+        raise ArgumentError, 'Must provide either an encrypted hash result or encrypted string and salt.'
+      end
+      key = EzCrypto::Key.with_password(TwitterAuth.encryption_key, salt)
+      key.decrypt64(encrypted_data)
+    end
+  
+    def self.generate_salt
+      ActiveSupport::SecureRandom.hex(4)
+    end
+  end
+end
+

data/lib/twitter_auth/dispatcher/basic.rb

@@ -0,0 +1,46 @@
+require 'net/http'
+
+module TwitterAuth
+  module Dispatcher
+    class Basic
+      include TwitterAuth::Dispatcher::Shared
+
+      attr_accessor :user
+
+      def initialize(user)
+        raise TwitterAuth::Error, 'Dispatcher must be initialized with a User.' unless user.is_a?(TwitterAuth::BasicUser)
+        self.user = user
+      end
+
+      def request(http_method, path, body=nil, *arguments)
+        path = TwitterAuth.path_prefix + path
+        path = append_extension_to(path)
+
+        response = TwitterAuth.net.start{ |http|
+          req = "Net::HTTP::#{http_method.to_s.capitalize}".constantize.new(path, *arguments)
+          req.basic_auth user.login, user.password
+          req.set_form_data(body) unless body.nil?
+          http.request(req)
+        }
+        
+        handle_response(response)      
+      end
+
+      def get(path, *arguments)
+        request(:get, path, *arguments)
+      end
+
+      def post(path, body='', *arguments)
+        request(:post, path, body, *arguments)
+      end
+
+      def put(path, body='', *arguments)
+        request(:put, path, body, *arguments)
+      end
+
+      def delete(path, *arguments)
+        request(:delete, path, *arguments)
+      end
+    end
+  end
+end

data/lib/twitter_auth/dispatcher/oauth.rb

@@ -0,0 +1,27 @@
+require 'oauth'
+
+module TwitterAuth
+  module Dispatcher
+    class Oauth < OAuth::AccessToken
+      include TwitterAuth::Dispatcher::Shared
+
+      attr_accessor :user
+
+      def initialize(user)
+        raise TwitterAuth::Error, 'Dispatcher must be initialized with a User.' unless user.is_a?(TwitterAuth::OauthUser) 
+        self.user = user
+        super(TwitterAuth.consumer, user.access_token, user.access_secret)
+      end
+
+      def request(http_method, path, *arguments)
+        path = "http://api.twitter.com/1" + path
+        #path = TwitterAuth.path_prefix + path
+        path = append_extension_to(path)
+
+        response = super
+
+        handle_response(response)
+      end
+    end
+  end
+end

data/lib/twitter_auth/dispatcher/shared.rb

@@ -0,0 +1,40 @@
+module TwitterAuth
+  module Dispatcher
+    module Shared
+      def post!(status)
+        self.post('/statuses/update.json', :status => status)
+      end
+
+      def append_extension_to(path)
+        path, query_string = *(path.split("?"))
+        path << '.json' unless path.match(/\.(:?xml|json)\z/i)
+        "#{path}#{"?#{query_string}" if query_string}"
+      end
+
+      def handle_response(response)
+        case response
+        when Net::HTTPOK 
+          begin
+            JSON.parse(response.body)
+          rescue JSON::ParserError
+            response.body
+          end
+        when Net::HTTPUnauthorized
+          raise TwitterAuth::Dispatcher::Unauthorized, 'The credentials provided did not authorize the user.'
+        else
+          message = begin
+            JSON.parse(response.body)['error']
+          rescue JSON::ParserError
+            if match = response.body.match(/<error>(.*)<\/error>/)
+              match[1]
+            else
+              'An error occurred processing your Twitter request.'
+            end
+          end
+
+          raise TwitterAuth::Dispatcher::Error, message
+        end
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,8 @@
+# Gem Dependencies
+config.gem 'oauth'
+config.gem 'ezcrypto'
+
+require 'json'
+require 'twitter_auth'
+
+RAILS_DEFAULT_LOGGER.info("** TwitterAuth initialized properly.")

data/spec/controllers/controller_extensions_spec.rb

@@ -0,0 +1,162 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect ':controller/:action/:id'
+end
+
+class TwitterAuthTestController < ApplicationController
+  before_filter :login_required, :only => [:login_required_action]
+
+  def login_required_action
+    render :text => "You are logged in!"
+  end
+
+  def fail_auth
+    authentication_failed('Auth FAIL.')
+  end
+
+  def pass_auth
+    if params[:message]
+      authentication_succeeded(params[:message])
+    else
+      authentication_succeeded
+    end
+  end
+
+  def access_denied_action
+    access_denied
+  end
+
+  def redirect_back_action
+    redirect_back_or_default(params[:to] || '/')
+  end
+
+  def logout_keeping_session_action
+    logout_keeping_session!
+    redirect_back_or_default('/')
+  end
+
+  def current_user_action
+    @user = current_user
+    render :nothing => true
+  end
+end
+
+describe TwitterAuthTestController do
+  before do
+    controller.stub!(:cookies).and_return({})
+  end
+
+  %w(authentication_failed authentication_succeeded current_user authorized? login_required access_denied store_location redirect_back_or_default logout_keeping_session!).each do |m|
+    it "should respond to the extension method '#{m}'" do
+      controller.should respond_to(m)
+    end
+  end
+
+  describe "#authentication_failed" do
+    it 'should set the flash[:error] to the message passed in' do
+      get :fail_auth
+      flash[:error].should == 'Auth FAIL.'
+    end
+
+    it 'should redirect to the root' do
+      get :fail_auth
+      should redirect_to('/')
+    end
+  end
+
+  describe "#authentication_succeeded" do
+    it 'should set the flash[:notice] to a default success message' do
+      get :pass_auth
+      flash[:notice].should == 'You have logged in successfully.' 
+    end
+
+    it 'should be able ot receive a custom message' do
+      get :pass_auth, :message => 'Eat at Joes.'
+      flash[:notice].should == 'Eat at Joes.'
+    end
+  end
+
+  describe '#current_user' do
+    it 'should find the user based on the session user_id' do
+      user = Factory.create(:twitter_oauth_user)
+      request.session[:user_id] = user.id
+      get(:current_user_action)
+      assigns[:user].should == user
+    end
+
+    it 'should log the user in through a cookie' do
+      user = Factory(:twitter_oauth_user, :remember_token => 'abc', :remember_token_expires_at => (Time.now + 10.days))
+      controller.stub!(:cookies).and_return({:remember_token => 'abc'})
+      get :current_user_action
+      assigns[:user].should == user
+    end
+
+    it 'should return nil if there is no user matching that id' do
+      request.session[:user_id] = 2345
+      get :current_user_action
+      assigns[:user].should be_nil
+    end
+  end
+
+  describe "#authorized?" do
+    it 'should be true if there is a current_user' do
+      user = Factory.create(:twitter_oauth_user)
+      controller.stub!(:current_user).and_return(user)
+      controller.send(:authorized?).should be_true
+    end
+
+    it 'should be false if there is not current_user' do
+      controller.stub!(:current_user).and_return(nil)
+      controller.send(:authorized?).should be_false
+    end
+  end
+
+  describe '#access_denied' do
+    it 'should redirect to the login path' do
+      get :access_denied_action
+      should redirect_to(login_path)
+    end
+
+    it 'should store the location first' do
+      controller.should_receive(:store_location).once
+      get :access_denied_action
+    end
+  end
+
+  describe '#redirect_back_or_default' do
+    it 'should redirect if there is a session[:return_to]' do
+      request.session[:return_to] = '/'
+      get :redirect_back_action, :to => '/notroot'
+      should redirect_to('/')
+    end
+
+    it 'should redirect to the default provided otherwise' do
+      get :redirect_back_action, :to => '/someurl'
+      should redirect_to('/someurl')
+    end
+  end
+
+  describe 'logout_keeping_session!' do
+    before do
+      @user = Factory.create(:twitter_oauth_user)
+      request.session[:user_id] = @user.id
+    end
+
+    it 'should unset session[:user_id]' do
+      get :logout_keeping_session_action
+      request.session[:user_id].should be_nil
+    end
+
+    it 'should unset current_user' do
+      controller.send(:current_user).should == @user
+      get :logout_keeping_session_action
+      controller.send(:current_user).should be_false
+    end
+
+    it 'should unset the cookie' do
+      controller.send(:cookies).should_receive(:delete).with(:remember_token)
+      get :logout_keeping_session_action
+    end
+  end
+end