jspooner-authlogic-connect 0.0.19

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Lance Pollard (lancejpollard@gmail.com)
+ 
+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.markdown

@@ -0,0 +1,234 @@
+# AuthlogicConnect
+
+> Instant Oauth and OpenID support for your Rails and Sinatra Apps
+
+AuthlogicConnect is an extension of the Authlogic library that adds complete Oauth and OpenID support to your application.  It provides a single interface to Oauth 1.0 and Oauth 2.0.
+
+It currently allows you to login with Github, Facebook, Twitter, Google, LinkedIn, MySpace, Vimeo, and Yahoo Oauth providers, and all the OpenID providers.  Feel free to add support for more as you need them.
+
+Here's a **[live example](http://authlogic-connect.heroku.com)** on Heroku ([with source](http://github.com/viatropos/authlogic-connect-example)).  [Here's the Docs](http://rdoc.info/projects/viatropos/authlogic-connect)
+
+### Lists of known providers:
+
+- [Oauth Providers](http://wiki.oauth.net/ServiceProviders)
+- [OpenID Providers](http://en.wikipedia.org/wiki/List_of_OpenID_providers)
+- [More OpenID](http://openid.net/get-an-openid/)
+
+## Install
+
+### 1. Install AuthlogicConnect
+
+    sudo gem install authlogic-connect
+
+### 2. Add the gem dependencies in your config:
+
+Rails 2.3.x: `config/environment.rb`
+
+    config.gem "json"
+    config.gem "authlogic"
+    config.gem "oauth"
+    config.gem "oauth2"
+    config.gem "authlogic-connect"
+
+Rails 3: `Gemfile`
+
+    gem "ruby-openid"
+    gem "rack-openid", ">=0.2.1", :require => "rack/openid"
+    gem "authlogic", :git => "git://github.com/odorcicd/authlogic.git", :branch => "rails3"
+    gem "oauth"
+    gem "oauth2"
+    gem "authlogic-connect"
+    
+### 3.  Add the OpenIdAuthentication.store
+
+Do to [some strange problem](http://github.com/openid/ruby-openid/issues#issue/1) I have yet to really understand, Rails 2.3.5 doesn't like when `OpenIdAuthentication.store` is null, which means it uses the "in memory" store and for some reason fails.
+
+So as a fix, if you are using Rails < 3, add these at the end of your `config/environment.rb` files:
+
+In development mode:
+
+    OpenIdAuthentication.store = :file
+    
+In production (on Heroku primarily)
+
+    OpenIdAuthentication.store = :memcache
+
+### 4. Add the Migrations
+
+See the [Rails 2 Example](http://github.com/viatropos/authlogic-connect-example-rails2) and [Rails 3 Example](http://github.com/viatropos/authlogic-connect-example) projects to see what you need.  Will add a generator sometime.
+
+Files needed are:
+
+- models: User, UserSession
+- controllers: UsersController, UserSessionsController, ApplicationController
+- migrations: create\_users, create\_sessions, create\_tokens
+- initializers: config/authlogic.example.yml, config/initializers/authlogic_connect_config.rb
+- routes
+    
+### 5. Configure your keys
+
+In `config/authlogic.yml`, write your keys and secrets for each service you would like to support.  You have to manually go to the websites and register with the service provider (list of those links coming soon, in token classes for now).
+
+    connect:
+      twitter:
+        key: "my_key"
+        secret: "my_secret"
+        label: "Twitter"
+      facebook:
+        key: "my_key"
+        secret: "my_secret"
+        label: "Facebook"
+      google:
+        key: "my_key"
+        secret: "my_secret"
+        label: "Google"
+      yahoo:
+        key: "my_key"
+        secret: "my_secret"
+        label: "Yahoo"
+      myspace:
+        key: "my_key"
+        secret: "my_secret"
+      vimeo:
+        key: "my_key"
+        secret: "my_secret"
+      linked_in:
+        key: "my_key"
+        secret: "my_secret"
+
+These are then loaded via the initializer script in `config/initializers/authlogic_connect_config.rb`:
+
+    AuthlogicConnect.config = YAML.load_file("config/authlogic.yml")
+
+### 6. Make sure you save your objects properly
+
+Because of the redirects involved in Oauth and OpenID, you MUST pass a block to the `save` method in your UsersController and UserSessionsController:
+
+    @user_session.save do |result|
+      if result
+        flash[:notice] # "Login successful!"
+        redirect_back_or_default account_url
+      else
+        render :action => :new
+      end
+    end
+
+If you don't use the block, we will get a DoubleRender error.  We need the block to jump out of the rendering while redirecting.
+  
+### 7. Add Parameters to Forms in your Views
+
+There are 3 things to include in your views.
+
+First, you must specify whether this is for _registration_ or _login_.  This is stored in the `authentication_type` key with a value of `user` for registration and `session` for login:
+
+    %input{:type => :hidden, :name => :authentication_type, :value => :user}
+    
+Second, if you are using Oauth, you must include an input with name `oauth_provider` and value `twitter` or whatever other provider you might want (see example apps for dynamic example).
+
+    %input{:type => :radio, :id => :twitter_oauth_provider, :name => :oauth_provider, :value => :twitter}
+    
+Finally, if you are using OpenID, you must include an input with name `openid_identifier`, which is a text field with the value the user types in for their address:
+
+    %input.nice{:type => :text, :name => :openid_identifier}
+
+Those are passed as parameters to Authlogic, and the complicated details are abstracted away.
+
+## Overview of the User Experience
+
+There are 3 ways you a user can login with AuthlogicConnect:
+
+1. Clicking an Oauth Provider
+2. Clicking an OpenID Provider and entering in their username
+3. Manually typing in a full OpenID address
+
+Oauth is very different from OpenID, but this aims to make them work the same.
+
+## Examples
+
+These are examples of what you can get from a User.  Code is placed in controller for demo purposes, it should be abstracted into the model.
+
+### API
+
+User model has the following public accessors and methods.  This example assumes:
+
+- You've associated your Google, OpenID, and Twitter accounts with this app.
+- You're currently logged in via Google.
+
+Inside the `show` method in a controller...
+
+    def show
+      @user = @current_user
+      
+      puts @user.tokens #=> [
+        #<OpenidToken id: 12, user_id: 9, type: "OpenidToken", key: "http://my-openid-login.myopenid.com/", token: nil, secret: nil, active: nil, created_at: "2010-05-24 14:52:19", updated_at: "2010-05-24 14:52:19">,
+        #<TwitterToken id: 13, user_id: 9, type: "TwitterToken", key: "my-twitter-id-123", token: "twitter-token", secret: "twitter-secret", active: nil, created_at: "2010-05-24 15:03:05", updated_at: "2010-05-24 15:03:05">,
+        #<GoogleToken id: 14, user_id: 9, type: "GoogleToken", key: "my-email@gmail.com", token: "google-token", secret: "google-secret", active: nil, created_at: "2010-05-24 15:09:04", updated_at: "2010-05-24 15:09:04">]
+          
+      puts @user.tokens.length #=> 3
+      
+      # currently logged in with...
+      puts @user.active_token #=> #<GoogleToken id: 14, user_id: 9, type: "GoogleToken", key: "my-email@gmail.com", token: "google-token", secret: "google-secret", active: nil, created_at: "2010-05-24 15:09:04", updated_at: "2010-05-24 15:09:04">
+        
+      puts @user.authenticated_with #=> ["twitter", "openid", "google"]
+      puts @user.authenticated_with?(:twitter) #=> true
+      puts @user.authenticated_with?(:facebook) #=> false
+      
+      puts @user.has_token?(:google) #=> true
+      
+      puts @user.get_token(:google) #=> #<GoogleToken id: 14, user_id: 9, type: "GoogleToken", key: "my-email@gmail.com", token: "google-token", secret: "google-secret", active: nil, created_at: "2010-05-24 15:09:04", updated_at: "2010-05-24 15:09:04">
+      
+      # change active_token
+      @user.active_token = @user.get_token(:twitter)
+      puts @user.active_token #=> #<TwitterToken id: 13, user_id: 9, type: "TwitterToken", key: "my-twitter-id-123", token: "twitter-token", secret: "twitter-secret", active: nil, created_at: "2010-05-24 15:03:05", updated_at: "2010-05-24 15:03:05">
+      
+      # access oauth api
+      @twitter = @user.active_token
+      @twitter_profile = JSON.parse(@twitter.get("/account/verify_credentials.json").body) #=> twitter api stuff
+      # ...
+    end
+
+### Get Facebook Data
+
+If they've associated their Facebook account with your site, you can access Facebook data.
+
+    def show
+      @user = @current_user
+      token = @user.active_token # assuming this is FacebookToken
+      facebook = JSON.parse(token.get("/me"))
+      @profile = {
+        :id     => facebook["id"],
+        :name   => facebook["name"],
+        :photo  => "https://graph.facebook.com/#{facebook["id"]}/picture",
+        :link   => facebook["link"],
+        :title  => "Facebook"
+      }
+      @profile = @user.profile
+    end
+
+## Helpful links
+
+*	**Authlogic:** [http://github.com/binarylogic/authlogic](http://github.com/binarylogic/authlogic)
+*	**AuthlogicConnect Example Project:** [http://github.com/viatropos/authlogic-connect-example](http://github.com/viatropos/authlogic-connect-example)
+*	**Live example with Twitter and Facebook using Rails 3:** [http://authlogic-connect.heroku.com](http://authlogic-connect.heroku.com)
+* **Rails 2.3.5 Example:** [http://github.com/viatropos/authlogic-connect-example-rails2](http://github.com/viatropos/authlogic-connect-example-rails2)
+* **Rubygems Repository:** [http://rubygems.org/gems/authlogic-connect](http://rubygems.org/gems/authlogic-connect)
+
+## Rest...
+
+Thanks for the people that are already extending the project, all the input making things move much faster.  [Andrew Cove](http://github.com/andrewacove) and [Daf](http://github.com/daf) have helped me quite a bit, thanks guys.
+
+Feel free to add to the wiki if you figure things out or make new distinctions.
+
+## Flow
+
+- Try to create a session
+- Session logs into provider
+- On success, if no user, redirect to User#create
+
+#### Notes
+
+- Build mechanize tool to automatically create applications with service providers.
+
+### Todo
+
+- Add [Andrew Cove's](http://github.com/andrewacove) idea of a "Merge Code".  So if user creates Facebook account logs out, and create Twitter account, a code they can use to pass to facebook account so it knows it's associated with Twitter.

data/Rakefile

@@ -0,0 +1,85 @@
+require 'rake'
+require "rake/rdoctask"
+require 'rake/gempackagetask'
+
+# http://docs.rubygems.org/read/chapter/20
+spec = Gem::Specification.new do |s|
+  s.name              = "jspooner-authlogic-connect"
+  s.author            = "Lance Pollard"
+  s.version           = "0.0.19"
+  s.summary           = "Authlogic Connect: Oauth and OpenID made dead simple"
+  s.homepage          = "http://github.com/jspooner/authlogic-connect"
+  s.email             = "lancejpollard@gmail.com"
+  s.description       = "Oauth and OpenID made dead simple"
+  s.has_rdoc          = true
+  s.rubyforge_project = "jspooner-authlogic-connect"
+  s.platform          = Gem::Platform::RUBY
+  s.files             = %w(README.markdown Rakefile init.rb MIT-LICENSE) + Dir["{lib,rails,test}/**/*"] - Dir["test/tmp"]
+  s.require_path      = "lib"
+  s.add_dependency("activesupport", ">= 2.1.2")
+  s.add_dependency("activerecord", ">= 2.1.2")
+  s.add_dependency("json")
+  s.add_dependency("ruby-openid")
+  s.add_dependency("rack-openid", ">=0.2.1")
+  s.add_dependency("oauth")
+  s.add_dependency("oauth2")
+  s.add_dependency("authlogic")
+end
+
+desc "Create .gemspec file (useful for github)"
+task :gemspec do
+  File.open("pkg/#{spec.name}.gemspec", "w") do |f|
+    f.puts spec.to_ruby
+  end
+end
+
+desc "Build the gem into the current directory"
+task :gem => :gemspec do
+  `gem build pkg/#{spec.name}.gemspec`
+end
+
+desc "Publish gem to rubygems"
+task :publish => [:package] do
+  %x[gem push pkg/#{spec.name}-#{spec.version}.gem]
+end
+
+desc "Print a list of the files to be put into the gem"
+task :manifest do
+  File.open("Manifest", "w") do |f|
+    spec.files.each do |file|
+      f.puts file
+    end
+  end
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec    = spec
+  pkg.package_dir = "pkg"
+end
+
+desc "Install the gem locally"
+task :install => [:package] do
+  sh %{gem install pkg/#{spec.name}-#{spec.version} --no-ri --no-rdoc}
+end
+
+desc "Generate the rdoc"
+Rake::RDocTask.new do |rdoc|
+  files = ["README.markdown", "lib/**/*.rb"]
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.markdown"
+  rdoc.title = spec.summary
+end
+
+task :yank do
+  `gem yank #{spec.name} -v #{spec.version}`
+end
+
+desc 'run unit tests'
+task :test do
+  Dir["test/**/*"].each do |file|
+    next unless File.extname(file) == ".rb"
+    next unless File.basename(file) =~ /test_/
+    next if File.basename(file) =~ /test_helper/
+    system "ruby #{file}"
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+File.dirname(__FILE__) + "/rails/init.rb"

data/lib/authlogic-connect.rb

@@ -0,0 +1,39 @@
+require 'active_record'
+require "rubygems"
+require 'authlogic'
+require 'oauth'
+require 'oauth2'
+
+this = File.dirname(__FILE__)
+library = "#{this}/authlogic_connect"
+
+require "#{this}/open_id_authentication"
+require "#{library}/ext"
+require "#{library}/authlogic_connect"
+require "#{library}/callback_filter"
+require "#{library}/access_token"
+require "#{library}/openid"
+require "#{library}/oauth"
+require "#{library}/common"
+require "#{library}/engine" if defined?(Rails) && Rails::VERSION::MAJOR == 3
+
+custom_models =   ["#{library}/access_token"]
+custom_models +=  Dir["#{library}/oauth/tokens"]
+custom_models +=  Dir["#{library}/openid/tokens"]
+
+# Rails 3/2 config
+load_path_method = ActiveSupport::Dependencies.respond_to?(:autoload_paths) ? :autoload_paths : :load_paths
+
+custom_models.each do |path|
+  $LOAD_PATH << path
+  ActiveSupport::Dependencies.send(load_path_method) << path
+end
+
+# Rails 3beta4 backport
+if defined?(ActiveSupport::HashWithIndifferentAccess)
+  ActiveSupport::HashWithIndifferentAccess.class_eval do
+    def symbolize_keys!
+      symbolize_keys
+    end
+  end
+end

data/lib/authlogic_connect/access_token.rb

@@ -0,0 +1,61 @@
+class AccessToken < ActiveRecord::Base
+  belongs_to :user
+  
+  def client
+    self.class.client
+  end
+  
+  def consumer
+    self.class.consumer
+  end
+  
+  def service_name
+    self.class.service_name
+  end
+  
+  def settings
+    self.class.settings
+  end
+  
+  def config
+    self.class.config
+  end
+  
+  def get(path)
+    
+  end
+  
+  class << self
+    def service_name
+      @service_name ||= self.to_s.underscore.scan(/^(.*?)(_token)?$/)[0][0].to_sym
+    end
+    
+    def client
+      raise "implement client in subclass"
+    end
+    
+    def consumer
+      raise "implement consumer in subclass"
+    end
+    
+    def settings(site, hash = {})
+      @settings = hash.merge(:site => site)
+    end
+    
+    def config
+      @settings ||= {}
+      @settings.dup
+    end
+    
+    def api_version(value = nil)
+      config[:api]
+    end
+    
+    protected
+    
+    def credentials
+      @credentials ||= AuthlogicConnect.credentials(service_name)
+    end
+  end
+  
+end

data/lib/authlogic_connect/authlogic_connect.rb

@@ -0,0 +1,46 @@
+module AuthlogicConnect
+  KEY = "connect" unless defined?(KEY)
+  OAUTH = "oauth" unless defined?(OAUTH)
+  OPEN_ID = "open_id" unless defined?(OPEN_ID)
+  
+  class << self
+    
+    attr_accessor :config
+    
+    def config=(value)
+      value.recursively_symbolize_keys!
+      @config = value
+    end
+    
+    def key(path)
+      result = self.config
+      path.to_s.split(".").each { |node| result = result[node.to_sym] if result }
+      result
+    end
+    
+    def credentials(service)
+      key("#{KEY}.#{service.to_s}")
+    end
+    
+    def services
+      key(KEY)
+    end
+    
+    def service_names
+      services.keys.collect(&:to_s)
+    end
+    
+    def include?(service)
+      !credentials(service).nil?
+    end
+    
+    def token(key)
+      raise "can't find key '#{key.to_s}' in AuthlogicConnect.config" unless AuthlogicConnect.include?(key) and !key.to_s.empty?
+      "#{key.to_s.camelcase}Token".constantize
+    end
+    
+    def consumer(key)
+      token(key).consumer
+    end
+  end
+end

data/lib/authlogic_connect/callback_filter.rb

@@ -0,0 +1,19 @@
+class AuthlogicConnect::CallbackFilter
+  def initialize(app)
+    @app = app
+  end
+  
+  # this intercepts how the browser interprets the url.
+  # so we override it and say,
+  # "if we've stored a variable in the session called :auth_callback_method,
+  # then convert that into a POST call so we re-call the original method"
+  def call(env)
+    if env["rack.session"].nil?
+      raise "Make sure you are setting the session in Rack too!  Place this in config/application.rb"
+    end
+    unless env["rack.session"][:auth_callback_method].blank?
+      env["REQUEST_METHOD"] = env["rack.session"].delete(:auth_callback_method).to_s.upcase
+    end
+    @app.call(env)
+  end
+end

data/lib/authlogic_connect/common/session.rb

@@ -0,0 +1,30 @@
+module AuthlogicConnect::Common
+  module Session
+    
+    def self.included(base)    
+      base.class_eval do
+        include Variables
+        include InstanceMethods
+      end
+    end
+    
+    module InstanceMethods
+      
+      # core save method coordinating how to save the session.
+      # want to destroy the block if we redirect to a remote service, that's it.
+      # otherwise the block contains the render methods we wan to use
+      def save(&block)
+        self.errors.clear
+        # log_state
+        authenticate_via_protocol(block_given?) do |redirecting|
+          block = nil if redirecting
+          result = super(&block)
+          cleanup_authentication_session unless block.nil?
+          result
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/authlogic_connect/common/state.rb

@@ -0,0 +1,45 @@
+# This class holds query/state variables common to oauth and openid
+module AuthlogicConnect::Common::State
+  
+  def auth_controller?
+    !auth_controller.blank?
+  end
+
+  def auth_params?
+    auth_controller? && !auth_params.blank?
+  end
+  
+  def auth_session?
+    !auth_session.blank?
+  end
+  
+  def is_auth_session?
+    self.is_a?(Authlogic::Session::Base)
+  end
+  
+  def start_authentication?
+    start_oauth? || start_openid?
+  end
+  
+  def validate_password_with_oauth?
+    !using_openid? && super
+  end
+  
+  def validate_password_with_openid?
+    !using_oauth? && super
+  end
+  
+  # because user and session are so closely tied together, I am still
+  # uncertain as to how they are saved.  So this makes sure if we are
+  # logging in, it must be saving the session, otherwise the user.
+  def correct_request_class?
+    return false unless auth_params?
+    
+    if is_auth_session?
+      auth_type.to_s == "session"
+    else
+      auth_type.to_s == "user"
+    end
+  end
+  
+end

data/lib/authlogic_connect/common/user.rb

@@ -0,0 +1,77 @@
+# This class is the main api for the user.
+# It is also required to properly sequence the save methods
+# for the different authentication types (oauth and openid)
+module AuthlogicConnect::Common::User
+    
+  def self.included(base)
+    base.class_eval do
+      add_acts_as_authentic_module(InstanceMethods, :append)
+      add_acts_as_authentic_module(AuthlogicConnect::Common::Variables, :prepend)
+    end
+  end
+  
+  module InstanceMethods
+    
+    def self.included(base)
+      base.class_eval do
+        has_many :access_tokens, :class_name => "AccessToken", :dependent => :destroy
+        belongs_to :active_token, :class_name => "AccessToken", :dependent => :destroy
+        accepts_nested_attributes_for :access_tokens, :active_token
+      end
+    end
+    
+    def authenticated_with
+      @authenticated_with ||= self.access_tokens.collect{|t| t.service_name.to_s}
+    end
+    
+    def authenticated_with?(service)
+      self.access_tokens.detect{|t| t.service_name.to_s == service.to_s}
+    end
+    
+    def update_attributes(attributes, &block)
+      self.attributes = attributes
+      save(:validate => true, &block)
+    end
+    
+    def has_token?(service_name)
+      !get_token(service_name).nil?
+    end
+    
+    def get_token(service_name)
+      self.access_tokens.detect {|i| i.service_name.to_s == service_name.to_s}
+    end
+    
+    # core save method coordinating how to save the user.
+    # we dont' want to ru validations based on the 
+    # authentication mission we are trying to accomplish.
+    # instead, we just return save as false.
+    # the next time around, when we recieve the callback,
+    # we will run the validations.
+    # when you call 'current_user_session' in ApplicationController,
+    # it leads to calling 'save' on this User object via "session.record.save",
+    # from the 'persisting?' method.  So we don't want any of this to occur
+    # when that save is called, and the only way to check currently is
+    # to check if there is a block_given?
+    def save(options = {}, &block)
+      self.errors.clear
+      # log_state
+      options = {} if options == false
+      options[:validate] = true unless options.has_key?(:validate)
+      save_options = ActiveRecord::VERSION::MAJOR < 3 ? options[:validate] : options
+      
+      # kill the block if we're starting authentication
+      authenticate_via_protocol(block_given?, options) do |start_authentication|
+        block = nil if start_authentication # redirecting
+        # forces you to validate, only if a block is given
+        result = super(save_options) # validate!
+        unless block.nil?
+          cleanup_authentication_session(options)
+          yield(result)
+        end
+        result
+      end
+    end
+    
+  end
+  
+end