authlogic-connect 0.0.3.9 → 0.0.4.03

data/README.markdown

@@ -1,8 +1,8 @@
 # AuthlogicConnect
 
-AuthlogicConnect is an extension of the Authlogic library to add extensive Oauth and OpenID support.
+AuthlogicConnect is an extension of the Authlogic library that aims to add complete and seamless Oauth and OpenID support to your application.
 
-It allows you to login through any of the 30+ Oauth and OpenID providers on the Internet.
+It allows you to login through any of the 30+ Oauth and OpenID providers on the Internet without having to write any of the logic yourself.
 
 That makes life easy and gives you a lot of power.
 
@@ -32,7 +32,7 @@ AuthlogicConnect currently allows you to login with 7 Oauth providers and all th
 - [OpenID Providers](http://en.wikipedia.org/wiki/List_of_OpenID_providers)
 - [More OpenID](http://openid.net/get-an-openid/)
 
-## Install and use
+## Install
 
 ### 1. Install AuthlogicConnect
 
@@ -57,7 +57,7 @@ Rails 3: `Gemfile`
     gem "oauth2"
     gem "authlogic-connect"
     
-### 3.  Add the `OpenIdAuthentication.store`
+### 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.
 
@@ -237,4 +237,8 @@ Thanks for the people that are already extending the project, all the input maki
 
 Feel free to add to the wiki if you figure things out or make new distinctions.
 
-https://rpxnow.com/features
+## Flow
+
+- Try to create a session
+- Session logs into provider
+- On success, if no user, redirect to User#create

data/Rakefile

@@ -6,11 +6,11 @@ require 'rake/gempackagetask'
 spec = Gem::Specification.new do |s|
   s.name              = "authlogic-connect"
   s.author            = "Lance Pollard"
-  s.version           = "0.0.3.9"
-  s.summary           = "Authlogic Connect: Let your app use all of Oauth and OpenID"
+  s.version           = "0.0.4.03"
+  s.summary           = "Authlogic Connect: Oauth and OpenID made dead simple"
   s.homepage          = "http://github.com/viatropos/authlogic-connect"
   s.email             = "lancejpollard@gmail.com"
-  s.description       = "Let your app use all of Oauth and OpenID"
+  s.description       = "Oauth and OpenID made dead simple"
   s.has_rdoc          = true
   s.rubyforge_project = "authlogic-connect"
   s.platform          = Gem::Platform::RUBY
@@ -68,4 +68,8 @@ Rake::RDocTask.new do |rdoc|
   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

data/lib/authlogic-connect.rb

@@ -11,13 +11,13 @@ require "#{this}/open_id_authentication"
 require "#{library}/ext"
 require "#{library}/authlogic_connect"
 require "#{library}/callback_filter"
-require "#{library}/token"
+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}/token"]
+custom_models =   ["#{library}/access_token"]
 custom_models +=  Dir["#{library}/oauth/tokens"]
 custom_models +=  Dir["#{library}/openid/tokens"]
 

data/lib/authlogic_connect/{token.rb → access_token.rb}

@@ -1,4 +1,4 @@
-class Token < ActiveRecord::Base
+class AccessToken < ActiveRecord::Base
   belongs_to :user
   
   def client

data/lib/authlogic_connect/common/session.rb

@@ -1,7 +1,7 @@
 module AuthlogicConnect::Common
   module Session
     
-    def self.included(base)
+    def self.included(base)    
       base.class_eval do
         include Variables
         include InstanceMethods
@@ -10,18 +10,21 @@ module AuthlogicConnect::Common
     
     module InstanceMethods
       
-      # core save method coordinating how to save the session
+      # 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)
-        block_destroyed = false
-        if authenticating_with_openid?
-          block_destroyed = save_with_openid(&block)
-        elsif authenticating_with_oauth?
-          block_destroyed = save_with_oauth(&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
-        block = nil if block_destroyed
-        super(&block)
       end
+      
     end
     
   end
-end
+end

data/lib/authlogic_connect/common/state.rb

@@ -1,16 +1,32 @@
 # This class holds query/state variables common to oauth and openid
 module AuthlogicConnect::Common::State
   
-  def auth_session?
-    !auth_session.blank?
+  def auth_controller?
+    !auth_controller.blank?
   end
-  
+
   def auth_params?
-    !auth_params.blank?
+    auth_controller? && !auth_params.blank?
+  end
+  
+  def auth_session?
+    !auth_session.blank?
   end
   
   def is_auth_session?
     self.is_a?(Authlogic::Session::Base)
   end
   
-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
+  
+end

data/lib/authlogic_connect/common/user.rb

@@ -14,18 +14,18 @@ module AuthlogicConnect::Common::User
     
     def self.included(base)
       base.class_eval do
-        has_many :tokens, :class_name => "Token", :dependent => :destroy
-        belongs_to :active_token, :class_name => "Token", :dependent => :destroy
-        accepts_nested_attributes_for :tokens, :active_token
+        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.tokens.collect{|t| t.service_name.to_s}
+      @authenticated_with ||= self.access_tokens.collect{|t| t.service_name.to_s}
     end
     
     def authenticated_with?(service)
-      self.tokens.detect{|t| t.service_name.to_s == service.to_s}
+      self.access_tokens.detect{|t| t.service_name.to_s == service.to_s}
     end
     
     def update_attributes(attributes, &block)
@@ -38,7 +38,7 @@ module AuthlogicConnect::Common::User
     end
     
     def get_token(service_name)
-      self.tokens.detect {|i| i.service_name.to_s == service_name.to_s}
+      self.access_tokens.detect {|i| i.service_name.to_s == service_name.to_s}
     end
     
     # core save method coordinating how to save the user.
@@ -46,68 +46,30 @@ module AuthlogicConnect::Common::User
     # 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
+    # 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)
-      # debug_user_save_pre(options, &block)
+      self.errors.clear
+      # log_state
       options = {} if options == false
-      unless options[:skip_redirect] == true
-        return false if remotely_authenticating?(&block)
-      end
-      # forces you to validate, maybe get rid of if needed,
-      # but everything depends on this
-      if ActiveRecord::VERSION::MAJOR < 3
-        result = super(true) # validate!
-      else
-        result = super(options.merge(:validate => true))
-      end
-      # debug_user_save_post
-      yield(result) if block_given? # give back to controller
+      options[:validate] = true unless options.has_key?(:validate)
+      save_options = ActiveRecord::VERSION::MAJOR < 3 ? options[:validate] : options
       
-      cleanup_auth_session if result && !(options.has_key?(:keep_session) && options[:keep_session])
-      
-      result
-    end
-    
-    def remotely_authenticating?(&block)
-      return redirecting_to_oauth_server? if using_oauth? && block_given?
-      return redirecting_to_openid_server? if using_openid?
-      return false
-    end
-    
-    # it only reaches this point once it has returned, or you
-    # have manually skipped the redirect and save was called directly.
-    def cleanup_auth_session
-      cleanup_oauth_session
-      cleanup_openid_session
-    end
-    
-    def validate_password_with_oauth?
-      !using_openid? && super
-    end
-    
-    def validate_password_with_openid?
-      !using_oauth? && super
-    end
-    
-    # test methods for dev/debugging, commented out by default
-    def debug_user_save_pre(options = {}, &block)
-      puts "USER SAVE "
-      puts "block_given? #{block_given?.to_s}"
-      puts "using_oauth? #{using_oauth?.to_s}"
-      puts "using_openid? #{using_openid?.to_s}"
-      puts "authenticating_with_oauth? #{authenticating_with_oauth?.to_s}"
-      puts "authenticating_with_openid? #{authenticating_with_openid?.to_s}"
-      puts "validate_password_with_oauth? #{validate_password_with_oauth?.to_s}"
-      puts "validate_password_with_openid? #{validate_password_with_openid?.to_s}"
-      puts "!using_openid? && require_password? #{(!using_openid? && require_password?).to_s}"
-    end
-    
-    def debug_user_save_post
-      puts "ERRORS: #{errors.full_messages}"
-      puts "using_oauth? #{using_oauth?.to_s}"
-      puts "using_openid? #{using_openid?.to_s}"
-      puts "validate_password_with_oauth? #{validate_password_with_oauth?.to_s}"
-      puts "validate_password_with_openid? #{validate_password_with_openid?.to_s}"
+      # kill the block if we're starting authentication
+      authenticate_via_protocol(block_given?, options) do |redirecting|
+        block = nil if 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

data/lib/authlogic_connect/common/variables.rb

@@ -1,19 +1,18 @@
 module AuthlogicConnect::Common::Variables
   include AuthlogicConnect::Common::State
+
+  attr_reader :processing_authentication
   
-  def auth_controller
-    is_auth_session? ? controller : session_class.controller
+  def auth_class
+    is_auth_session? ? self.class : session_class
   end
   
-  def auth_session
-    auth_controller.session.symbolize_keys!
-    auth_controller.session.keys.each do |key|
-      auth_controller.session[key.to_s] = auth_controller.session.delete(key) if key.to_s =~ /^OpenID/
-    end
-    auth_controller.session
+  def auth_controller
+    is_auth_session? ? controller : session_class.controller
   end
   
   def auth_params
+    return nil unless auth_controller?
     auth_controller.params.symbolize_keys!
     auth_controller.params.keys.each do |key|
       auth_controller.params[key.to_s] = auth_controller.params.delete(key) if key.to_s =~ /^OpenID/
@@ -21,6 +20,15 @@ module AuthlogicConnect::Common::Variables
     auth_controller.params
   end
   
+  def auth_session
+    return nil unless auth_controller?
+    auth_controller.session.symbolize_keys!
+    auth_controller.session.keys.each do |key|
+      auth_controller.session[key.to_s] = auth_controller.session.delete(key) if key.to_s =~ /^OpenID/
+    end
+    auth_controller.session
+  end
+  
   def auth_callback_url(options = {})
     auth_controller.url_for({:controller => auth_controller.controller_name, :action => auth_controller.action_name}.merge(options))
   end
@@ -31,10 +39,11 @@ module AuthlogicConnect::Common::Variables
   end
   
   # auth_params and auth_session attributes are all String!
-  def from_session_or_params(by)
-    key = by.is_a?(Symbol) ? by : by.to_sym
+  def from_session_or_params(attribute)
+    return nil unless auth_controller?
+    key = attribute.is_a?(Symbol) ? attribute : attribute.to_sym
     result = auth_params[key] if (auth_params && auth_params[key])
-    result = auth_session[key] if result.blank? # might be null here too
+    result = auth_session[key] if (result.nil? || result.blank?)
     result
   end
   
@@ -42,6 +51,8 @@ module AuthlogicConnect::Common::Variables
   # 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
@@ -53,6 +64,55 @@ module AuthlogicConnect::Common::Variables
     
   end
   
+  def remove_session_key(key)
+    keys = key.is_a?(Symbol) ? [key, key.to_s] : [key, key.to_sym]
+    keys.each {|k| auth_session.delete(k)}
+  end
+    
+  # wraps the call to "save" (in yield).
+  # reason being, we need to somehow not allow oauth/openid validations to run
+  # when we don't have a block.  We can't know that using class methods, so we create
+  # this property "processing_authentication", which is used in the validation method.
+  # it's value is set to "block_given", which is the value of block_given?
+  def authenticate_via_protocol(block_given = false, options = {}, &block)
+    @processing_authentication = auth_controller? && block_given
+    saved = yield start_authentication?
+    @processing_authentication = false
+    saved
+  end
+  
+  # returns boolean
+  def authentication_protocol(with, phase)
+    returning(send("#{phase.to_s}_#{with.to_s}?")) do |ready|
+      send("#{phase.to_s}_#{with.to_s}") if ready
+    end if send("using_#{with.to_s}?")
+  end
+  
+  # it only reaches this point once it has returned, or you
+  # have manually skipped the redirect and save was called directly.
+  def cleanup_authentication_session(options = {}, &block)
+    unless (options.has_key?(:keep_session) && options[:keep_session])
+      %w(oauth openid).each do |type|
+        send("cleanup_#{type.to_s}_session")
+      end
+    end
+  end
+  
+  def log(*methods)
+    methods.each do |method|
+      puts "#{method.to_s}: #{send(method).inspect}"
+    end
+  end
+    
+  def log_state
+    log(:correct_request_class?)
+    log(:using_oauth?, :start_oauth?, :complete_oauth?)
+    log(:oauth_request?, :oauth_response?, :stored_oauth_token_and_secret?)
+    log(:using_openid?, :start_openid?, :complete_openid?, :openid_request?, :openid_response?)
+    log(:authenticating_with_openid?)
+    log(:stored_oauth_token_and_secret)
+  end
+  
   # because we may need to store 6+ session variables, all with pretty lengthy names,
   # might as well just tinify them.
   # just an idea
@@ -70,4 +130,8 @@ module AuthlogicConnect::Common::Variables
     @optimized_session_keys[key]
   end
   
+  def auto_register?
+    true
+  end
+  
 end

data/lib/authlogic_connect/oauth/process.rb

@@ -4,15 +4,13 @@ module AuthlogicConnect::Oauth::Process
 
   # Step 2: after save is called, it runs this method for validation
   def validate_by_oauth
-    validate_email_field = false
-    unless new_oauth_request? # shouldn't be validating if it's redirecting...
-      restore_attributes
-      complete_oauth_transaction
+    if processing_authentication
+      authentication_protocol(:oauth, :start) || authentication_protocol(:oauth, :complete)
     end
   end
   
   # Step 3: if new_oauth_request?, redirect to oauth provider
-  def redirect_to_oauth
+  def start_oauth
     save_oauth_session
     authorize_url = token_class.authorize_url(auth_callback_url) do |request_token|
       save_auth_session_token(request_token) # only for oauth version 1
@@ -20,6 +18,17 @@ module AuthlogicConnect::Oauth::Process
     auth_controller.redirect_to authorize_url
   end
   
+  # Step 4: on callback, run this method
+  def complete_oauth
+    # implemented in User and Session Oauth modules
+    unless new_oauth_request? # shouldn't be validating if it's redirecting...
+      restore_attributes
+      complete_oauth_transaction
+      return true
+    end
+    return false
+  end
+  
   # Step 3a: save our passed-parameters into the session,
   # so we can retrieve them after the redirect calls back
   def save_oauth_session
@@ -45,11 +54,6 @@ module AuthlogicConnect::Oauth::Process
   def restore_attributes
   end
   
-  # Step 4: on callback, run this method
-  def authenticate_with_oauth
-    # implemented in User and Session Oauth modules
-  end
-  
   # Step last, after the response
   # having lots of trouble testing logging and out multiple times,
   # so there needs to be a solid way to know when a user has messed up loggin in.
@@ -61,8 +65,11 @@ module AuthlogicConnect::Oauth::Process
       :oauth_provider,
       :auth_callback_method,
       :oauth_request_token,
-      :oauth_request_token_secret
-    ].each {|key| auth_session.delete(key)}
+      :oauth_request_token_secret,
+      :_key,
+      :_token,
+      :_secret,
+    ].each {|key| remove_session_key(key)}
   end
     
 end