authlogic-connect 0.0.3.4 → 0.0.3.6

data/lib/authlogic_connect/oauth/tokens/twitter_token.rb

@@ -1,5 +1,7 @@
 class TwitterToken < OauthToken
   
+  key :user_id
+  
   settings "http://twitter.com",
     :authorize_url => "http://twitter.com/oauth/authenticate"
   

data/lib/authlogic_connect/oauth/user.rb

@@ -1,85 +1,68 @@
-module AuthlogicConnect::Oauth
-  module User
+module AuthlogicConnect::Oauth::User
+  
+  def self.included(base)
+    base.class_eval do
+      # add_acts_as_authentic_module makes sure it is
+      # only added to the user model, not all activerecord models.
+      add_acts_as_authentic_module(InstanceMethods, :prepend)
+    end
+  end
+  
+  module InstanceMethods
+    include AuthlogicConnect::Oauth::Process
+    
+    # Set up some simple validations
     def self.included(base)
       base.class_eval do
-        add_acts_as_authentic_module(InstanceMethods, :prepend)
+        
+        validate :validate_by_oauth, :if => :authenticating_with_oauth?
+        
+        # need these validation options if you don't want it to choke
+        # on password length, which you don't need if you're using oauth
+        validates_length_of_password_field_options validates_length_of_password_field_options.merge(:if => :validate_password_with_oauth?)
+        validates_confirmation_of_password_field_options validates_confirmation_of_password_field_options.merge(:if => :validate_password_with_oauth?)
+        validates_length_of_password_confirmation_field_options validates_length_of_password_confirmation_field_options.merge(:if => :validate_password_with_oauth?)
+        validates_length_of_login_field_options validates_length_of_login_field_options.merge(:if => :validate_password_with_oauth?)
+        validates_format_of_login_field_options validates_format_of_login_field_options.merge(:if => :validate_password_with_oauth?)
       end
+      
+      # email needs to be optional for oauth
+      base.validate_email_field = false
+    end
+        
+    # user adds a few extra things to this method from Process
+    # modules work like inheritance
+    def save_oauth_session
+      super
+      auth_session[:auth_attributes]            = attributes.reject!{|k, v| v.blank?} unless is_auth_session?
     end
     
-    module InstanceMethods
-      include Process
-      # Set up some simple validations
-      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
-          
-          validate :validate_by_oauth, :if => :authenticating_with_oauth?
-          
-          # need these validation options if you don't want it to choke
-          # on password length, which you don't need if you're using oauth
-          validates_length_of_password_field_options validates_length_of_password_field_options.merge(:if => :validate_password_with_oauth?)
-          validates_confirmation_of_password_field_options validates_confirmation_of_password_field_options.merge(:if => :validate_password_with_oauth?)
-          validates_length_of_password_confirmation_field_options validates_length_of_password_confirmation_field_options.merge(:if => :validate_password_with_oauth?)
-          validates_length_of_login_field_options validates_length_of_login_field_options.merge(:if => :validate_password_with_oauth?)
-          validates_format_of_login_field_options validates_format_of_login_field_options.merge(:if => :validate_password_with_oauth?)
-        end
-
-        # email needs to be optional for oauth
-        base.validate_email_field = false
-      end
-      
-      def update_attributes(attributes, &block)
-        self.attributes = attributes
-        save(true, &block)
-      end
-      
-      # NEED TO GIVE A BLOCK
-      def save_with_oauth(perform_validation = true, &block)
-        if perform_validation && block_given? && redirecting_to_oauth_server?
-          # Save attributes so they aren't lost during the authentication with the oauth server
-          auth_session[:authlogic_oauth_attributes] = attributes.reject!{|k, v| v.blank?}
-          redirect_to_oauth
-          return false
-        end
-        return true
-      end
-      
-    protected
+    def restore_attributes
+      # Restore any attributes which were saved before redirecting to the auth server
+      self.attributes = auth_session[:auth_attributes]
+    end
     
-      def using_oauth?
-        !oauth_token.blank?
-      end
-      
-      def validate_password_with_oauth?
-        !using_oauth? && require_password?
+    # single implementation method for oauth.
+    # this is called after we get the callback url and we are saving the user
+    # to the database.
+    # it is called by the validation chain.
+    def complete_oauth_transaction
+      unless create_oauth_token
+        self.errors.add(:tokens, "you have already created an account using your #{oauth_token.service_name} account, so it")
       end
+    end
+    
+    def create_oauth_token
+      token = token_class.new(oauth_token_and_secret)
       
-      def authenticating_with_oauth?
-        return false unless oauth_provider
-        # Initial request when user presses one of the button helpers
-        initial_request = (auth_params && !auth_params[:register_with_oauth].blank?)
-        # When the oauth provider responds and we made the initial request
-        initial_response = (oauth_response && auth_session && auth_session[:oauth_request_class] == self.class.name)
-        
-        return initial_request || initial_response
-      end
-
-      def authenticate_with_oauth
-        # Restore any attributes which were saved before redirecting to the oauth server
-        self.attributes = auth_session.delete(:authlogic_oauth_attributes)
-        token = AuthlogicConnect.token(oauth_provider).new(oauth_key_and_secret)
-        puts "NEW TOKEN: #{token.inspect}"
-        if old_token = Token.find_by_key(token.key)
-          puts "OLD TOKEN? #{old_token.inspect}"
-          self.errors.add("you have already created an account using your #{oauth_token.service_name} account, so it")
-        else
-          self.tokens << token
-          self.active_token = token
-        end
+      if has_token?(oauth_provider) || Token.find_by_key(token.key) || Token.find_by_token(token.token)
+        return false
+      else
+        self.tokens << token
+        self.active_token = token
+        return true
       end
-
     end
+    
   end
-end
+end

data/lib/authlogic_connect/oauth/variables.rb

@@ -1,30 +1,55 @@
-module AuthlogicConnect::Oauth
-  module Variables
-    
-    # These are just helper variables
-    def oauth_response
-      auth_params && oauth_key
-    end
-    
-    def oauth_key
-      return nil unless auth_controller
-      oauth_version == 1.0 ? auth_params[:oauth_token] : auth_params[:code]
-    end
-    
-    def oauth_version
-      oauth_token.oauth_version
-    end
-    
-    def oauth_provider
-      auth_session[:oauth_provider] || "facebook"
-    end
-    
-    def oauth_consumer
-      oauth_token.consumer
-    end
+module AuthlogicConnect::Oauth::Variables
+  include AuthlogicConnect::Oauth::State
+  
+  # this doesn't do anything yet, just to show what variables
+  # we need from the form
+  def oauth_variables
+    [:oauth_provider]
+  end
     
-    def oauth_token
-      AuthlogicConnect.token(oauth_provider)
-    end
+  # this comes straight from either the params or session.
+  # it is required for most of the other accessors in here
+  def oauth_provider
+    from_session_or_params(:oauth_provider)
+  end
+  
+  # next is "token_class", which is found from the oauth_provider key.
+  # it is the OauthToken subclass, such as TwitterToken, which we
+  # use as the api for accessing oauth and saving the response to the database for a user.
+  def token_class
+    AuthlogicConnect.token(oauth_provider) unless oauth_provider.blank?
+  end
+  
+  # This should go...
+  def oauth_response
+    auth_params && oauth_token
+  end
+  
+  # the token from the response parameters
+  def oauth_token
+    return nil unless token_class
+    oauth_version == 1.0 ? auth_params[:oauth_token] : auth_params[:code]
+  end
+  
+  # the version of oauth we're using.  Accessed from the OauthToken subclass
+  def oauth_version
+    token_class.oauth_version
+  end
+  
+  # the Oauth gem consumer, whereby we can make requests to the server
+  def oauth_consumer
+    token_class.consumer
+  end
+  
+  # this is a thick method.
+  # it gives you the final key and secret that we will store in the database
+  def oauth_token_and_secret
+    token_class.get_token_and_secret(
+      :token          => auth_session[:oauth_request_token],
+      :secret         => oauth_version == 1.0 ? auth_session[:oauth_request_token_secret] : oauth_token,
+      :oauth_verifier => auth_params[:oauth_verifier],
+      :redirect_uri   => auth_callback_url
+    )
   end
+  
 end

data/lib/authlogic_connect/openid.rb

@@ -1,6 +1,9 @@
 module AuthlogicConnect::Openid
 end
 
+require File.dirname(__FILE__) + "/openid/state"
+require File.dirname(__FILE__) + "/openid/variables"
+require File.dirname(__FILE__) + "/openid/process"
 require File.dirname(__FILE__) + "/openid/user"
 require File.dirname(__FILE__) + "/openid/session"
 

data/lib/authlogic_connect/openid/process.rb

@@ -0,0 +1,30 @@
+module AuthlogicConnect::Openid::Process
+
+  include AuthlogicConnect::Openid::Variables
+  
+  # want to do this after the final save
+  def cleanup_openid_session
+    [:auth_attributes, :authentication_type, :auth_callback_method].each {|key| auth_session.delete(key)}
+    auth_session.each_key do |key|
+      auth_session.delete(key) if key.to_s =~ /^OpenID/
+    end
+  end
+  
+  def validate_by_openid
+    errors.add(:tokens, "had the following error: #{@openid_error}") if @openid_error
+  end
+  
+  def save_openid_session
+    # Tell our rack callback filter what method the current request is using
+    auth_session[:auth_callback_method]   = auth_controller.request.method
+    auth_session[:auth_attributes]        = attributes_to_save
+    auth_session[:authentication_type]    = auth_params[:authentication_type]
+    auth_session[:auth_method]            = "openid"
+  end
+  
+  def restore_attributes
+    # Restore any attributes which were saved before redirecting to the auth server
+    self.attributes = auth_session[:auth_attributes]
+  end
+  
+end

data/lib/authlogic_connect/openid/session.rb

@@ -3,48 +3,16 @@ module AuthlogicConnect::Openid
   module Session
     # Add a simple openid_identifier attribute and some validations for the field.
     def self.included(klass)
-      klass.extend ClassMethods
       klass.class_eval do
         include InstanceMethods
       end
     end
     
-    module ClassMethods
-      # What method should we call to find a record by the openid_identifier?
-      # This is useful if you want to store multiple openid_identifiers for a single record.
-      # You could do something like:
-      #
-      #   class User < ActiveRecord::Base
-      #     def self.find_by_openid_identifier(identifier)
-      #       user.first(:conditions => {:openid_identifiers => {:identifier => identifier}})
-      #     end
-      #   end
-      #
-      # Obviously the above depends on what you are calling your assocition, etc. But you get the point.
-      #
-      # * <tt>Default:</tt> :find_by_openid_identifier
-      # * <tt>Accepts:</tt> Symbol
-      def find_by_openid_identifier_method(value = nil)
-        rw_config(:find_by_openid_identifier_method, value, :find_by_openid_identifier)
-      end
-      alias_method :find_by_openid_identifier_method=, :find_by_openid_identifier_method
-      
-      # Add this in your Session object to Auto Register a new user using openid via sreg
-      def auto_register(value=true)
-        auto_register_value(value)
-      end
-      
-      def auto_register_value(value=nil)
-        rw_config(:auto_register,value,false)
-      end
-      
-      alias_method :auto_register=,:auto_register
-    end
-    
     module InstanceMethods
+      include AuthlogicConnect::Openid::Process
+      
       def self.included(klass)
         klass.class_eval do
-          attr_reader :openid_identifier
           validate :validate_openid_error
           validate :validate_by_openid, :if => :authenticating_with_openid?
         end
@@ -58,18 +26,10 @@ module AuthlogicConnect::Openid
         self.openid_identifier = hash[:openid_identifier] if !hash.nil? && hash.key?(:openid_identifier)
       end
       
-      def openid_identifier=(value)
-        @openid_identifier = value.blank? ? nil : OpenIdAuthentication.normalize_identifier(value)
-        @openid_error = nil
-      rescue OpenIdAuthentication::InvalidOpenId => e
-        @openid_identifier = nil
-        @openid_error = e.message
-      end
-      
       # Cleaers out the block if we are authenticating with OpenID, so that we can redirect without a DoubleRender
       # error.
       def save_with_openid(&block)
-        block = nil if !openid_identifier.blank?
+        block = nil if Token.find_by_key(openid_identifier.normalize_identifier)
         return block.nil?
       end
       
@@ -78,21 +38,14 @@ module AuthlogicConnect::Openid
           attempted_record.nil? && errors.empty? && (!openid_identifier.blank? || (controller.params[:open_id_complete] && controller.params[:for_session]))
         end
         
-        def find_by_openid_identifier_method
-          self.class.find_by_openid_identifier_method
-        end
-
-        def find_by_openid_identifier_method
-          self.class.find_by_openid_identifier_method
-        end
-        
         def auto_register?
-          self.class.auto_register_value
+          false
         end
         
         def validate_by_openid
           self.remember_me = auth_params[:remember_me] == "true" if auth_params.key?(:remember_me)
-          self.attempted_record = klass.send(find_by_openid_identifier_method, openid_identifier)
+          token = Token.find_by_key(openid_identifier.normalize_identifier, :include => [:user])
+          self.attempted_record = token.user if token
           if !attempted_record
             if auto_register?
               self.attempted_record = klass.new :openid_identifier => openid_identifier

data/lib/authlogic_connect/openid/state.rb

@@ -0,0 +1,47 @@
+# all these methods must return true or false
+module AuthlogicConnect::Openid::State
+    # 1. to call
+    def openid_request?
+      !openid_identifier.blank?
+    end
+    
+    def openid_identifier?
+      openid_request?
+    end
+    
+    def openid_provider?
+      
+    end
+    
+    # 2. from call
+    # better check needed
+    def openid_response?
+      !auth_session[:auth_attributes].nil? && auth_session[:auth_method] == "openid"
+    end
+    alias_method :openid_complete?, :openid_response?
+    
+    # 3. either to or from call
+    # this should include more!
+    # we know we are using open id if:
+    #   the params passed in have "openid_identifier"
+    def using_openid?
+      openid_request? || openid_response?
+    end
+    
+    def authenticating_with_openid?
+      session_class.activated? && using_openid?
+    end
+    
+    def allow_openid_redirect?
+      authenticating_with_openid?
+    end
+    
+    def redirecting_to_openid_server?
+      allow_openid_redirect? && !authenticate_with_openid
+    end
+    
+    def validate_password_with_openid?
+      !using_openid? && require_password?
+    end
+    
+end

data/lib/authlogic_connect/openid/tokens/my_openid_token.rb

@@ -0,0 +1,3 @@
+class MyOpenidToken < OpenidToken
+  
+end

data/lib/authlogic_connect/openid/tokens/openid_token.rb

@@ -1,3 +1,9 @@
 class OpenidToken < Token
   
+  before_save :format_identifier
+  
+  def format_identifier
+    self.key = self.key.to_s.normalize_identifier unless self.key.blank?
+  end
+  
 end

data/lib/authlogic_connect/openid/user.rb

@@ -2,18 +2,17 @@ module AuthlogicConnect::Openid
   module User
     def self.included(base)
       base.class_eval do
-        add_acts_as_authentic_module(InstanceMethods, :prepend)
+        add_acts_as_authentic_module(AuthlogicConnect::Openid::Process, :prepend)
+        add_acts_as_authentic_module(InstanceMethods, :append)
       end
     end
     
     module InstanceMethods
-
-      def self.included(base)
-        return if !base.column_names.include?("openid_identifier")
-        
+      
+      def self.included(base)        
         base.class_eval do
-          validates_uniqueness_of :openid_identifier, :scope => validations_scope, :if => :using_openid?
-          validate :validate_openid
+          validate :validate_by_openid, :if => :authenticating_with_openid?
+          
           validates_length_of_password_field_options validates_length_of_password_field_options.merge(:if => :validate_password_with_openid?)
           validates_confirmation_of_password_field_options validates_confirmation_of_password_field_options.merge(:if => :validate_password_with_openid?)
           validates_length_of_password_confirmation_field_options validates_length_of_password_confirmation_field_options.merge(:if => :validate_password_with_openid?)
@@ -22,71 +21,42 @@ module AuthlogicConnect::Openid
         end
       end
       
-      def openid_identifier=(value)
-        write_attribute(:openid_identifier, value.blank? ? nil : value.to_s.normalize_identifier)
-        reset_persistence_token if openid_identifier_changed?
-      rescue Exception => e
-        @openid_error = e.message
+      def authenticate_with_openid
+        @openid_error = nil
+        if !openid_response?
+          save_openid_session
+        else
+          restore_attributes
+        end
+        options = {}
+        options[:return_to] = auth_callback_url(:for_model => "1", :action => "create")
+        auth_controller.send(:authenticate_with_open_id, openid_identifier, options) do |result, openid_identifier|
+          create_openid_token(result, openid_identifier)
+          return true
+        end
+        return false
       end
       
-      def save_with_openid(perform_validation = true, &block)
-        return false if perform_validation && block_given? && authenticating_with_openid? && !authenticating_with_openid
-        return true
+      def create_openid_token(result, openid_identifier)
+        if result.unsuccessful?
+          @openid_error = result.message
+        elsif Token.find_by_key(openid_identifier.normalize_identifier)
+        else
+          token = OpenidToken.new(:key => openid_identifier)
+          self.tokens << token
+          self.active_token = token
+        end
       end
       
-      protected
-        
-        def validate_openid
-          errors.add(:openid_identifier, "had the following error: #{@openid_error}") if @openid_error
-        end
-        
-        def using_openid?
-          respond_to?(:openid_identifier) && !auth_params[:openid_identifier].blank?
-        end
-        
-        def openid_complete?
-          auth_session[:openid_attributes]
-        end
-        
-        def authenticating_with_openid?
-          session_class.activated? && ((using_openid?) || openid_complete?)
-        end
-        
-        def validate_password_with_openid?
-          !using_openid? && require_password?
-        end
-        
-        def authenticating_with_openid
-          @openid_error = nil
-          if !openid_complete?
-            # Tell our rack callback filter what method the current request is using
-            auth_session[:auth_callback_method]   = auth_controller.request.method
-            auth_session[:openid_attributes]      = attributes_to_save
-          else
-            self.attributes                       = auth_session.delete(:openid_attributes)
-          end
-          
-          options = {}
-          options[:return_to] = auth_controller.url_for(:for_model => "1", :controller => "users", :action => "create")
-          auth_controller.send(:authenticate_with_open_id, openid_identifier, options) do |result, openid_identifier, registration|
-            if result.unsuccessful?
-              @openid_error = result.message
-            else
-              self.openid_identifier = openid_identifier
-            end
-            return true
-          end
-          return false
-        end
-        
-        def attributes_to_save
-          attrs_to_save = attributes.clone.delete_if do |k, v|
-            [:id, :password, crypted_password_field, password_salt_field, :persistence_token, :perishable_token, :single_access_token, :login_count, 
-              :failed_login_count, :last_request_at, :current_login_at, :last_login_at, :current_login_ip, :last_login_ip, :created_at,
-              :updated_at, :lock_version].include?(k.to_sym)
-          end
-          attrs_to_save.merge!(:password => password, :password_confirmation => password_confirmation)
-        end
+      def attributes_to_save
+        attr_list = [:id, :password, crypted_password_field, password_salt_field, :persistence_token, :perishable_token, :single_access_token, :login_count, 
+          :failed_login_count, :last_request_at, :current_login_at, :last_login_at, :current_login_ip, :last_login_ip, :created_at,
+          :updated_at, :lock_version]
+        attrs_to_save = attributes.clone.delete_if do |k, v|
+          attr_list.include?(k.to_sym)
+        end
+        attrs_to_save.merge!(:password => password, :password_confirmation => password_confirmation)
+      end
     end
   end
 end