authlogic-oid 1.0.2 → 1.0.3

data/CHANGELOG.rdoc

@@ -1,3 +1,11 @@
+== 1.0.3 released 2009-4-3
+
+* Added find_by_openid_identifier config option for AuthlogicOpenid::Session.
+* Set the openid_identifier by the one passed back by the provider in AuthlogicOpenid::ActsAsAuthentic.
+* Added required_fields and optional_fields config options for AuthlogicOpenid::ActsAsAuthentic.
+* Added map_openid_registration, attributes_to_save, and map_saved_attributes methods to customize how attributes are set for AuthlogicOpenid::ActsAsAuthentic.
+* Make authenticating_with_openid? method a little more stringent to avoid trying to double authenticate. Ex: finding a session in the save block during a successful save.
+
 == 1.0.2 released 2009-3-30
 
 * Remove config block in initializer.

data/README.rdoc

@@ -4,7 +4,7 @@ Authlogic OpenID is an extension of the Authlogic library to add OpenID support.
 
 == Helpful links
 
-*	<b>Documentation:</b> http://authlogic.rubyforge.org
+*	<b>Documentation:</b> http://authlogic-oid.rubyforge.org
 *	<b>Authlogic:</b> http://github.com/binarylogic/authlogic
 *	<b>Live example:</b> http://authlogicexample.binarylogic.com
 

data/lib/authlogic_openid/acts_as_authentic.rb

@@ -8,10 +8,35 @@ module AuthlogicOpenid
     # OpenID is being used.
     def self.included(klass)
       klass.class_eval do
+        extend Config
         add_acts_as_authentic_module(Methods, :prepend)
       end
     end
     
+    module Config
+      # Some OpenID providers support a lightweight profile exchange protocol, for those that do, you can require
+      # certain fields. This is convenient for new registrations, as it will basically fill out the fields in the
+      # form for them, so they don't have to re-type information already stored with their OpenID account.
+      #
+      # For more info and what fields you can use see: http://openid.net/specs/openid-simple-registration-extension-1_0.html
+      #
+      # * <tt>Default:</tt> []
+      # * <tt>Accepts:</tt> Array of symbols
+      def required_fields(value = nil)
+        config(:required_fields, value, [])
+      end
+      alias_method :required_fields=, :required_fields
+      
+      # Same as required_fields, but optional instead.
+      #
+      # * <tt>Default:</tt> []
+      # * <tt>Accepts:</tt> Array of symbols
+      def optional_fields(value = nil)
+        config(:optional_fields, value, [])
+      end
+      alias_method :optional_fields=, :optional_fields
+    end
+    
     module Methods
       # Set up some simple validations
       def self.included(klass)
@@ -57,27 +82,22 @@ module AuthlogicOpenid
           @openid_error = nil
           
           if !openid_complete?
-            attrs_to_persist = attributes.delete_if do |k, v|
-              [: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_persist.merge!(:password => password, :password_confirmation => password_confirmation)
-            session_class.controller.session[:openid_attributes] = attrs_to_persist
+            session_class.controller.session[:openid_attributes] = attributes_to_save
           else
-            self.attributes = session_class.controller.session[:openid_attributes]
+            map_saved_attributes(session_class.controller.session[:openid_attributes])
             session_class.controller.session[:openid_attributes] = nil
           end
           
           options = {}
-          options[:required_field] = [self.class.login_field, self.class.email_field].compact
-          options[:optional_fields] = [:fullname]
+          options[:required] = self.class.required_fields
+          options[:optional] = self.class.optional_fields
           options[:return_to] = session_class.controller.url_for(:for_model => "1")
           
           session_class.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
               map_openid_registration(registration)
             end
             
@@ -87,10 +107,43 @@ module AuthlogicOpenid
           return false
         end
         
-        def map_openid_registration(registration)
+        # Override this method to map the OpenID registration fields with fields in your model. See the required_fields and
+        # optional_fields configuration options to enable this feature.
+        #
+        # Basically you will get a hash of values passed as a single argument. Then just map them as you see fit. Check out
+        # the source of this method for an example.
+        def map_openid_registration(registration) # :doc:
           self.name ||= registration[:fullname] if respond_to?(:name) && !registration[:fullname].blank?
           self.first_name ||= registration[:fullname].split(" ").first if respond_to?(:first_name) && !registration[:fullname].blank?
-          self.first_name ||= registration[:fullname].split(" ").last if respond_to?(:last_name) && !registration[:last_name].blank?
+          self.last_name ||= registration[:fullname].split(" ").last if respond_to?(:last_name) && !registration[:last_name].blank?
+        end
+        
+        # This method works in conjunction with map_saved_attributes.
+        #
+        # Let's say a user fills out a registration form, provides an OpenID and submits the form. They are then redirected to their
+        # OpenID provider. All is good and they are redirected back. All of those fields they spent time filling out are forgetten
+        # and they have to retype them all. To avoid this, AuthlogicOpenid saves all of these attributes in the session and then
+        # attempts to restore them. See the source for what attributes it saves. If you need to block more attributes, or save
+        # more just override this method and do whatever you want.
+        def attributes_to_save # :doc:
+          attrs_to_save = attributes.clone.delete_if do |k, v|
+            [: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
+        
+        # This method works in conjunction with attributes_to_save. See that method for a description of the why these methods exist.
+        #
+        # If the default behavior of this method is not sufficient for you because you have attr_protected or attr_accessible then
+        # override this method and set them individually. Maybe something like this would be good:
+        #
+        #   attrs.each do |key, value|
+        #     send("#{key}=", value)
+        #   end
+        def map_saved_attributes(attrs) # :doc:
+          self.attributes = attrs
         end
         
         def validate_openid

data/lib/authlogic_openid/session.rb

@@ -4,58 +4,92 @@ module AuthlogicOpenid
     # Add a simple openid_identifier attribute and some validations for the field.
     def self.included(klass)
       klass.class_eval do
-        attr_reader :openid_identifier
-        validate :validate_openid_error
-        validate :validate_by_openid, :if => :authenticating_with_openid?
+        extend Config
+        include Methods
       end
     end
     
-    # Hooks into credentials so that you can pass an :openid_identifier key.
-    def credentials=(value)
-      super
-      values = value.is_a?(Array) ? value : [value]
-      hash = values.first.is_a?(Hash) ? values.first.with_indifferent_access : nil
-      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(&block)
-      block = nil if !openid_identifier.blank?
-      super(&block)
-    end
-  
-    private
-      def authenticating_with_openid?
-        !openid_identifier.blank? || (controller.params[:open_id_complete] && controller.params[:for_session])
+    module Config
+      # 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)
+        config(:find_by_openid_identifier_method, value, :find_by_openid_identifier)
       end
+      alias_method :find_by_openid_identifier_method=, :find_by_openid_identifier_method
+    end
     
-      def validate_by_openid
-        controller.send(:authenticate_with_open_id, openid_identifier, :return_to => controller.url_for(:for_session => "1")) do |result, openid_identifier|
-          if result.unsuccessful?
-            errors.add_to_base(result.message)
-            return
-          end
-
-          self.attempted_record = klass.find_by_openid_identifier(openid_identifier)
-
-          if !attempted_record
-            errors.add(:openid_identifier, "did not match any users in our database, have you set up your account to use OpenID?")
-            return
-          end
+    module Methods
+      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
       end
       
-      def validate_openid_error
-        errors.add(:openid_identifier, @openid_error) if @openid_error
+      # Hooks into credentials so that you can pass an :openid_identifier key.
+      def credentials=(value)
+        super
+        values = value.is_a?(Array) ? value : [value]
+        hash = values.first.is_a?(Hash) ? values.first.with_indifferent_access : nil
+        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(&block)
+        block = nil if !openid_identifier.blank?
+        super(&block)
+      end
+      
+      private
+        def authenticating_with_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 validate_by_openid
+          controller.send(:authenticate_with_open_id, openid_identifier, :return_to => controller.url_for(:for_session => "1")) do |result, openid_identifier|
+            if result.unsuccessful?
+              errors.add_to_base(result.message)
+              return
+            end
+            
+            self.attempted_record = klass.send(find_by_openid_identifier_method, openid_identifier)
+            
+            if !attempted_record
+              errors.add(:openid_identifier, "did not match any users in our database, have you set up your account to use OpenID?")
+              return
+            end
+          end
+        end
+        
+        def validate_openid_error
+          errors.add(:openid_identifier, @openid_error) if @openid_error
+        end
+    end
   end
 end

data/lib/authlogic_openid/version.rb

@@ -41,7 +41,7 @@ module AuthlogicOpenid
 
     MAJOR = 1
     MINOR = 0
-    TINY  = 2
+    TINY  = 3
 
     # The current version as a Version instance
     CURRENT = new(MAJOR, MINOR, TINY)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: authlogic-oid
 version: !ruby/object:Gem::Version 
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors: 
 - Ben Johnson of Binary Logic
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-30 00:00:00 -04:00
+date: 2009-04-03 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,7 +30,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.11.0
+        version: 1.12.1
     version: 
 description: Extension of the Authlogic library to add OpenID support.
 email: bjohnson@binarylogic.com