xaviershay-twitter-auth 0.1.19

data/config/routes.rb

@@ -0,0 +1,6 @@
+ActionController::Routing::Routes.draw do |map|
+  map.login '/login', :controller => 'sessions', :action => 'new'
+  map.logout '/logout', :controller => 'sessions', :action => 'destroy'
+  map.resource :session
+  map.oauth_callback '/oauth_callback', :controller => 'sessions', :action => 'oauth_callback'
+end

data/generators/twitter_auth/USAGE

@@ -0,0 +1,12 @@
+TwitterAuth Generator
+=====================
+
+The TwitterAuth generator allows you to generate the components necessary to implement Twitter as a Single Sign-On provider for your site.
+
+To run it, you simply need to call it:
+
+script/generate twitter_auth
+
+This will generate the migration necessary for the users table as well as generate a User model that extends the appropriate TwitterAuth model template and a config/twitter.yml that allows you to set your OAuth consumer key and secret. 
+
+By default, TwitterAuth uses OAuth as its authentication strategy. If you wish to use HTTP Basic you can pass in the --basic option.

data/generators/twitter_auth/templates/migration.rb

@@ -0,0 +1,48 @@
+class TwitterAuthMigration < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string :login
+<% if options[:oauth] -%>
+      t.string :access_token
+      t.string :access_secret
+<% elsif options[:basic] -%>
+      t.binary :crypted_password
+      t.string :salt
+<% end -%>
+
+      t.string :remember_token
+      t.datetime :remember_token_expires_at
+
+      # This information is automatically kept
+      # in-sync at each login of the user. You
+      # may remove any/all of these columns.
+      t.string :name
+      t.string :location
+      t.string :description
+      t.string :profile_image_url
+      t.string :url
+      t.boolean :protected
+      t.string :profile_background_color
+      t.string :profile_sidebar_fill_color
+      t.string :profile_link_color
+      t.string :profile_sidebar_border_color
+      t.string :profile_text_color
+      t.string :profile_background_image_url
+      t.boolean :profile_background_tiled
+      t.integer :friends_count
+      t.integer :statuses_count
+      t.integer :followers_count
+      t.integer :favourites_count
+
+      # Probably don't need both, but they're here.
+      t.integer :utc_offset
+      t.string :time_zone
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :users
+  end
+end

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,99 @@
+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 ].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,69 @@
+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_to destination
+    end
+
+    def current_user
+      @current_user ||= User.find_by_id(session[:user_id]) || User.from_remember_token(cookies[:remember_token])
+    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!
+      @current_user = nil
+      session[:user_id] = nil
+      cookies.delete(:remember_token)
+    end
+
+    def build_user(user)
+      # Hook for applications to set additional user attributes on create
+    end
+  end
+end
+
+ActionController::Base.send(:include, TwitterAuth::ControllerExtensions)

data/lib/twitter_auth/cryptify.rb

@@ -0,0 +1,30 @@
+module TwitterAuth
+  module Cryptify
+    class Error < StandardError; end
+    
+    def self.encrypt(data)
+      salt = generate_salt
+      {:encrypted_data => EzCrypto::Key.encrypt_with_password(TwitterAuth.encryption_key, salt, 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
+
+      EzCrypto::Key.decrypt_with_password(TwitterAuth.encryption_key, salt, 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,26 @@
+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 = 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