authlogic 3.4.6 → 3.5.0

data/lib/authlogic.rb

@@ -55,5 +55,5 @@ path = File.dirname(__FILE__) + "/authlogic/"
    require path + library
  end
 
-require path + "controller_adapters/rails_adapter"   if defined?( Rails   )
-require path + "controller_adapters/sinatra_adapter" if defined?( Sinatra )
+require path + "controller_adapters/rails_adapter"   if defined?(Rails)
+require path + "controller_adapters/sinatra_adapter" if defined?(Sinatra)

data/lib/authlogic/acts_as_authentic/base.rb

@@ -67,11 +67,12 @@ module Authlogic
         end
 
         private
+
           def db_setup?
             begin
               column_names
               true
-            rescue Exception
+            rescue StandardError
               false
             end
           end
@@ -99,4 +100,3 @@ end
 ::ActiveRecord::Base.send :include, Authlogic::ActsAsAuthentic::SessionMaintenance
 ::ActiveRecord::Base.send :include, Authlogic::ActsAsAuthentic::SingleAccessToken
 ::ActiveRecord::Base.send :include, Authlogic::ActsAsAuthentic::ValidationsScope
-

data/lib/authlogic/acts_as_authentic/email.rb

@@ -41,11 +41,11 @@ module Authlogic
         # * <tt>Default:</tt> {:maximum => 100}
         # * <tt>Accepts:</tt> Hash of options accepted by validates_length_of
         def validates_length_of_email_field_options(value = nil)
-          rw_config(:validates_length_of_email_field_options, value, {:maximum => 100})
+          rw_config(:validates_length_of_email_field_options, value, { :maximum => 100 })
         end
         alias_method :validates_length_of_email_field_options=, :validates_length_of_email_field_options
 
-        # A convenience function to merge options into the validates_length_of_email_field_options. So intead of:
+        # A convenience function to merge options into the validates_length_of_email_field_options. So instead of:
         #
         #   self.validates_length_of_email_field_options = validates_length_of_email_field_options.merge(:my_option => my_value)
         #
@@ -56,19 +56,46 @@ module Authlogic
           self.validates_length_of_email_field_options = validates_length_of_email_field_options.merge(options)
         end
 
-        # A hash of options for the validates_format_of call for the email field. Allows you to change this however you want.
+        # A hash of options for the validates_format_of call for the email
+        # field. Allows you to change this however you want.
         #
-        # <b>Keep in mind this is ruby. I wanted to keep this as flexible as possible, so you can completely replace the hash or
-        # merge options into it. Checkout the convenience function merge_validates_format_of_email_field_options to merge
-        # options.</b>
+        # <b>Keep in mind this is ruby. I wanted to keep this as flexible as
+        # possible, so you can completely replace the hash or merge options into
+        # it. Checkout the convenience function
+        # merge_validates_format_of_email_field_options to merge options.</b>
+        #
+        # To validate international email addresses, enable the provided
+        # alternate regex:
         #
-        # To validate international email addresses, enable the provided alternate regex:
         # * <tt>validates_format_of_email_field_options({:with => Authlogic::Regex.email_nonascii})</tt>
         #
-        # * <tt>Default:</tt> {:with => Authlogic::Regex.email, :message => Proc.new {I18n.t('error_messages.email_invalid', :default => "should look like an email address.")}}
+        # * <tt>Default:</tt>
+        #
+        #         {
+        #           :with => Authlogic::Regex.email,
+        #           :message => Proc.new {
+        #             I18n.t(
+        #               'error_messages.email_invalid',
+        #               :default => "should look like an email address."
+        #             )
+        #           }
+        #         }
+        #
         # * <tt>Accepts:</tt> Hash of options accepted by validates_format_of
         def validates_format_of_email_field_options(value = nil)
-          rw_config(:validates_format_of_email_field_options, value, {:with => Authlogic::Regex.email, :message => Proc.new{I18n.t('error_messages.email_invalid', :default => "should look like an email address.")}})
+          rw_config(
+            :validates_format_of_email_field_options,
+            value,
+            {
+              :with => Authlogic::Regex.email,
+              :message => Proc.new do
+                I18n.t(
+                  'error_messages.email_invalid',
+                  :default => "should look like an email address."
+                )
+              end
+            }
+          )
         end
         alias_method :validates_format_of_email_field_options=, :validates_format_of_email_field_options
 
@@ -77,16 +104,34 @@ module Authlogic
           self.validates_format_of_email_field_options = validates_format_of_email_field_options.merge(options)
         end
 
-        # A hash of options for the validates_uniqueness_of call for the email field. Allows you to change this however you want.
+        # A hash of options for the validates_uniqueness_of call for the email
+        # field. Allows you to change this however you want.
         #
-        # <b>Keep in mind this is ruby. I wanted to keep this as flexible as possible, so you can completely replace the hash or
-        # merge options into it. Checkout the convenience function merge_validates_uniqueness_of_email_field_options to merge
+        # <b>Keep in mind this is ruby. I wanted to keep this as flexible as
+        # possible, so you can completely replace the hash or merge options into
+        # it. Checkout the convenience function
+        # merge_validates_uniqueness_of_email_field_options to merge
         # options.</b>
         #
-        # * <tt>Default:</tt> {:case_sensitive => false, :scope => validations_scope, :if => "#{email_field}_changed?".to_sym}
+        # * <tt>Default:</tt>
+        #
+        #         {
+        #           :case_sensitive => false,
+        #           :scope => validations_scope,
+        #           :if => "#{email_field}_changed?".to_sym
+        #         }
+        #
         # * <tt>Accepts:</tt> Hash of options accepted by validates_uniqueness_of
         def validates_uniqueness_of_email_field_options(value = nil)
-          rw_config(:validates_uniqueness_of_email_field_options, value, {:case_sensitive => false, :scope => validations_scope, :if => "#{email_field}_changed?".to_sym})
+          rw_config(
+            :validates_uniqueness_of_email_field_options,
+            value,
+            {
+              :case_sensitive => false,
+              :scope => validations_scope,
+              :if => "#{email_field}_changed?".to_sym
+            }
+          )
         end
         alias_method :validates_uniqueness_of_email_field_options=, :validates_uniqueness_of_email_field_options
 

data/lib/authlogic/acts_as_authentic/logged_in_status.rb

@@ -31,8 +31,8 @@ module Authlogic
 
           klass.class_eval do
             include InstanceMethods
-            scope :logged_in, lambda{ where("last_request_at > ? and current_login_at IS NOT NULL", logged_in_timeout.seconds.ago) }
-            scope :logged_out, lambda{ where("last_request_at is NULL or last_request_at <= ?", logged_in_timeout.seconds.ago) }
+            scope :logged_in, lambda { where("last_request_at > ? and current_login_at IS NOT NULL", logged_in_timeout.seconds.ago) }
+            scope :logged_out, lambda { where("last_request_at is NULL or last_request_at <= ?", logged_in_timeout.seconds.ago) }
           end
         end
 
@@ -49,6 +49,7 @@ module Authlogic
           end
 
           private
+
             def logged_in_timeout
               self.class.logged_in_timeout
             end
@@ -56,4 +57,4 @@ module Authlogic
       end
     end
   end
-end
+end

data/lib/authlogic/acts_as_authentic/login.rb

@@ -38,7 +38,7 @@ module Authlogic
         # * <tt>Default:</tt> {:within => 3..100}
         # * <tt>Accepts:</tt> Hash of options accepted by validates_length_of
         def validates_length_of_login_field_options(value = nil)
-          rw_config(:validates_length_of_login_field_options, value, {:within => 3..100})
+          rw_config(:validates_length_of_login_field_options, value, { :within => 3..100 })
         end
         alias_method :validates_length_of_login_field_options=, :validates_length_of_login_field_options
 
@@ -59,10 +59,31 @@ module Authlogic
         # merge options into it. Checkout the convenience function merge_validates_format_of_login_field_options to merge
         # options.</b>
         #
-        # * <tt>Default:</tt> {:with => Authlogic::Regex.login, :message => lambda {I18n.t('error_messages.login_invalid', :default => "should use only letters, numbers, spaces, and .-_@ please.")}}
+        # * <tt>Default:</tt>
+        #
+        #         {
+        #           :with => Authlogic::Regex.login,
+        #           :message => lambda {
+        #             I18n.t(
+        #               'error_messages.login_invalid',
+        #               :default => "should use only letters, numbers, spaces, and .-_@+ please."
+        #             )
+        #           }
+        #         }
+        #
         # * <tt>Accepts:</tt> Hash of options accepted by validates_format_of
         def validates_format_of_login_field_options(value = nil)
-          rw_config(:validates_format_of_login_field_options, value, {:with => Authlogic::Regex.login, :message => I18n.t('error_messages.login_invalid', :default => "should use only letters, numbers, spaces, and .-_@ please.")})
+          rw_config(
+            :validates_format_of_login_field_options,
+            value,
+            {
+              :with => Authlogic::Regex.login,
+              :message => I18n.t(
+                'error_messages.login_invalid',
+                :default => "should use only letters, numbers, spaces, and .-_@+ please."
+              )
+            }
+          )
         end
         alias_method :validates_format_of_login_field_options=, :validates_format_of_login_field_options
 
@@ -71,16 +92,33 @@ module Authlogic
           self.validates_format_of_login_field_options = validates_format_of_login_field_options.merge(options)
         end
 
-        # A hash of options for the validates_uniqueness_of call for the login field. Allows you to change this however you want.
+        # A hash of options for the validates_uniqueness_of call for the login
+        # field. Allows you to change this however you want.
         #
-        # <b>Keep in mind this is ruby. I wanted to keep this as flexible as possible, so you can completely replace the hash or
-        # merge options into it. Checkout the convenience function merge_validates_format_of_login_field_options to merge
-        # options.</b>
+        # <b>Keep in mind this is ruby. I wanted to keep this as flexible as
+        # possible, so you can completely replace the hash or merge options into
+        # it. Checkout the convenience function
+        # merge_validates_format_of_login_field_options to merge options.</b>
+        #
+        # * <tt>Default:</tt>
+        #
+        #         {
+        #           :case_sensitive => false,
+        #           :scope => validations_scope,
+        #           :if => "#{login_field}_changed?".to_sym
+        #         }
         #
-        # * <tt>Default:</tt> {:case_sensitive => false, :scope => validations_scope, :if => "#{login_field}_changed?".to_sym}
         # * <tt>Accepts:</tt> Hash of options accepted by validates_uniqueness_of
         def validates_uniqueness_of_login_field_options(value = nil)
-          rw_config(:validates_uniqueness_of_login_field_options, value, {:case_sensitive => false, :scope => validations_scope, :if => "#{login_field}_changed?".to_sym})
+          rw_config(
+            :validates_uniqueness_of_login_field_options,
+            value,
+            {
+              :case_sensitive => false,
+              :scope => validations_scope,
+              :if => "#{login_field}_changed?".to_sym
+            }
+          )
         end
         alias_method :validates_uniqueness_of_login_field_options=, :validates_uniqueness_of_login_field_options
 
@@ -112,18 +150,30 @@ module Authlogic
         end
 
         private
+
           def find_with_case(field, value, sensitivity = true)
+            ar_gem_version = Gem::Version.new(ActiveRecord::VERSION::STRING)
+
             relation = if not sensitivity
               connection.case_insensitive_comparison(arel_table, field.to_s, columns_hash[field.to_s], value)
+            elsif ar_gem_version >= Gem::Version.new('5.0')
+              connection.case_sensitive_comparison(arel_table, field.to_s, columns_hash[field.to_s], value)
             else
-              if Gem::Version.new(Rails.version) < Gem::Version.new('4.2')
+              if ar_gem_version < Gem::Version.new('4.2')
                 value = connection.case_sensitive_modifier(value)
               else
                 value = connection.case_sensitive_modifier(value, field.to_s)
               end
-              relation = arel_table[field.to_s].eq(value)
+              arel_table[field.to_s].eq(value)
+            end
+
+            # bind value in rails 5
+            if ar_gem_version >= Gem::Version.new('5')
+              bind = ActiveRecord::Relation::QueryAttribute.new(field.to_s, value, ActiveRecord::Type::Value.new)
+              where(relation, bind).first
+            else
+              where(relation).first
             end
-            where(relation).first
           end
       end
 

data/lib/authlogic/acts_as_authentic/magic_columns.rb

@@ -1,21 +1,32 @@
 module Authlogic
   module ActsAsAuthentic
-    # Magic columns are like ActiveRecord's created_at and updated_at columns. They are "magically" maintained for
-    # you. Authlogic has the same thing, but these are maintained on the session side. Please see Authlogic::Session::MagicColumns
-    # for more details. This module merely adds validations for the magic columns if they exist.
+    # Magic columns are like ActiveRecord's created_at and updated_at columns. They are
+    # "magically" maintained for you. Authlogic has the same thing, but these are
+    # maintained on the session side. Please see Authlogic::Session::MagicColumns for more
+    # details. This module merely adds validations for the magic columns if they exist.
     module MagicColumns
       def self.included(klass)
         klass.class_eval do
           add_acts_as_authentic_module(Methods)
         end
       end
-      
+
       # Methods relating to the magic columns
       module Methods
         def self.included(klass)
           klass.class_eval do
-            validates_numericality_of :login_count, :only_integer => true, :greater_than_or_equal_to => 0, :allow_nil => true if column_names.include?("login_count")
-            validates_numericality_of :failed_login_count, :only_integer => true, :greater_than_or_equal_to => 0, :allow_nil => true if column_names.include?("failed_login_count")
+            if column_names.include?("login_count")
+              validates_numericality_of :login_count,
+                :only_integer => true,
+                :greater_than_or_equal_to => 0,
+                :allow_nil => true
+            end
+            if column_names.include?("failed_login_count")
+              validates_numericality_of :failed_login_count,
+                :only_integer => true,
+                :greater_than_or_equal_to => 0,
+                :allow_nil => true
+            end
           end
         end
       end

data/lib/authlogic/acts_as_authentic/password.rb

@@ -1,7 +1,8 @@
 module Authlogic
   module ActsAsAuthentic
-    # This module has a lot of neat functionality. It is responsible for encrypting your password, salting it, and verifying it.
-    # It can also help you transition to a new encryption algorithm. See the Config sub module for configuration options.
+    # This module has a lot of neat functionality. It is responsible for encrypting your
+    # password, salting it, and verifying it. It can also help you transition to a new
+    # encryption algorithm. See the Config sub module for configuration options.
     module Password
       def self.included(klass)
         klass.class_eval do
@@ -18,7 +19,11 @@ module Authlogic
         # * <tt>Default:</tt> :crypted_password, :encrypted_password, :password_hash, or :pw_hash
         # * <tt>Accepts:</tt> Symbol
         def crypted_password_field(value = nil)
-          rw_config(:crypted_password_field, value, first_column_to_exist(nil, :crypted_password, :encrypted_password, :password_hash, :pw_hash))
+          rw_config(
+            :crypted_password_field,
+            value,
+            first_column_to_exist(nil, :crypted_password, :encrypted_password, :password_hash, :pw_hash)
+          )
         end
         alias_method :crypted_password_field=, :crypted_password_field
 
@@ -27,12 +32,16 @@ module Authlogic
         # * <tt>Default:</tt> :password_salt, :pw_salt, :salt, nil if none exist
         # * <tt>Accepts:</tt> Symbol
         def password_salt_field(value = nil)
-          rw_config(:password_salt_field, value, first_column_to_exist(nil, :password_salt, :pw_salt, :salt))
+          rw_config(
+            :password_salt_field,
+            value,
+            first_column_to_exist(nil, :password_salt, :pw_salt, :salt)
+          )
         end
         alias_method :password_salt_field=, :password_salt_field
 
-        # Whether or not to require a password confirmation. If you don't want your users to confirm their password
-        # just set this to false.
+        # Whether or not to require a password confirmation. If you don't want your users
+        # to confirm their password just set this to false.
         #
         # * <tt>Default:</tt> true
         # * <tt>Accepts:</tt> Boolean
@@ -41,14 +50,17 @@ module Authlogic
         end
         alias_method :require_password_confirmation=, :require_password_confirmation
 
-        # By default passwords are required when a record is new or the crypted_password is blank, but if both of these things
-        # are met a password is not required. In this case, blank passwords are ignored.
+        # By default passwords are required when a record is new or the crypted_password
+        # is blank, but if both of these things are met a password is not required. In
+        # this case, blank passwords are ignored.
         #
-        # Think about a profile page, where the user can edit all of their information, including changing their password.
-        # If they do not want to change their password they just leave the fields blank. This will try to set the password to
-        # a blank value, in which case is incorrect behavior. As such, Authlogic ignores this. But let's say you have a completely
-        # separate page for resetting passwords, you might not want to ignore blank passwords. If this is the case for you, then
-        # just set this value to false.
+        # Think about a profile page, where the user can edit all of their information,
+        # including changing their password. If they do not want to change their password
+        # they just leave the fields blank. This will try to set the password to a blank
+        # value, in which case is incorrect behavior. As such, Authlogic ignores this. But
+        # let's say you have a completely separate page for resetting passwords, you might
+        # not want to ignore blank passwords. If this is the case for you, then just set
+        # this value to false.
         #
         # * <tt>Default:</tt> true
         # * <tt>Accepts:</tt> Boolean
@@ -57,15 +69,16 @@ module Authlogic
         end
         alias_method :ignore_blank_passwords=, :ignore_blank_passwords
 
-        # When calling valid_password?("some pass") do you want to check that password against what's in that object or whats in
-        # the database. Take this example:
+        # When calling valid_password?("some pass") do you want to check that password
+        # against what's in that object or whats in the database. Take this example:
         #
         #   u = User.first
         #   u.password = "new pass"
         #   u.valid_password?("old pass")
         #
-        # Should the last line above return true or false? The record hasn't been saved yet, so most would assume true.
-        # Other would assume false. So I let you decide by giving you this option.
+        # Should the last line above return true or false? The record hasn't been saved
+        # yet, so most would assume true. Other would assume false. So I let you decide by
+        # giving you this option.
         #
         # * <tt>Default:</tt> true
         # * <tt>Accepts:</tt> Boolean
@@ -83,22 +96,26 @@ module Authlogic
         end
         alias_method :validate_password_field=, :validate_password_field
 
-        # A hash of options for the validates_length_of call for the password field. Allows you to change this however you want.
+        # A hash of options for the validates_length_of call for the password field.
+        # Allows you to change this however you want.
         #
-        # <b>Keep in mind this is ruby. I wanted to keep this as flexible as possible, so you can completely replace the hash or
-        # merge options into it. Checkout the convenience function merge_validates_length_of_password_field_options to merge
+        # <b>Keep in mind this is ruby. I wanted to keep this as flexible as possible, so
+        # you can completely replace the hash or merge options into it. Checkout the
+        # convenience function merge_validates_length_of_password_field_options to merge
         # options.</b>
         #
-        # * <tt>Default:</tt> {:minimum => 4, :if => :require_password?}
+        # * <tt>Default:</tt> {:minimum => 8, :if => :require_password?}
         # * <tt>Accepts:</tt> Hash of options accepted by validates_length_of
         def validates_length_of_password_field_options(value = nil)
-          rw_config(:validates_length_of_password_field_options, value, {:minimum => 4, :if => :require_password?})
+          rw_config(:validates_length_of_password_field_options, value, { :minimum => 8, :if => :require_password? })
         end
         alias_method :validates_length_of_password_field_options=, :validates_length_of_password_field_options
 
-        # A convenience function to merge options into the validates_length_of_login_field_options. So intead of:
+        # A convenience function to merge options into the
+        # validates_length_of_login_field_options. So instead of:
         #
-        #   self.validates_length_of_password_field_options = validates_length_of_password_field_options.merge(:my_option => my_value)
+        #   self.validates_length_of_password_field_options =
+        #     validates_length_of_password_field_options.merge(:my_option => my_value)
         #
         # You can do this:
         #
@@ -107,44 +124,56 @@ module Authlogic
           self.validates_length_of_password_field_options = validates_length_of_password_field_options.merge(options)
         end
 
-        # A hash of options for the validates_confirmation_of call for the password field. Allows you to change this however you want.
+        # A hash of options for the validates_confirmation_of call for the password field.
+        # Allows you to change this however you want.
         #
-        # <b>Keep in mind this is ruby. I wanted to keep this as flexible as possible, so you can completely replace the hash or
-        # merge options into it. Checkout the convenience function merge_validates_length_of_password_field_options to merge
+        # <b>Keep in mind this is ruby. I wanted to keep this as flexible as possible, so
+        # you can completely replace the hash or merge options into it. Checkout the
+        # convenience function merge_validates_length_of_password_field_options to merge
         # options.</b>
         #
         # * <tt>Default:</tt> {:if => :require_password?}
         # * <tt>Accepts:</tt> Hash of options accepted by validates_confirmation_of
         def validates_confirmation_of_password_field_options(value = nil)
-          rw_config(:validates_confirmation_of_password_field_options, value, {:if => :require_password?})
+          rw_config(:validates_confirmation_of_password_field_options, value, { :if => :require_password? })
         end
         alias_method :validates_confirmation_of_password_field_options=, :validates_confirmation_of_password_field_options
 
-        # See merge_validates_length_of_password_field_options. The same thing, except for validates_confirmation_of_password_field_options
+        # See merge_validates_length_of_password_field_options. The same thing, except for
+        # validates_confirmation_of_password_field_options
         def merge_validates_confirmation_of_password_field_options(options = {})
           self.validates_confirmation_of_password_field_options = validates_confirmation_of_password_field_options.merge(options)
         end
 
-        # A hash of options for the validates_length_of call for the password_confirmation field. Allows you to change this however you want.
+        # A hash of options for the validates_length_of call for the password_confirmation
+        # field. Allows you to change this however you want.
         #
-        # <b>Keep in mind this is ruby. I wanted to keep this as flexible as possible, so you can completely replace the hash or
-        # merge options into it. Checkout the convenience function merge_validates_length_of_password_field_options to merge
+        # <b>Keep in mind this is ruby. I wanted to keep this as flexible as possible, so
+        # you can completely replace the hash or merge options into it. Checkout the
+        # convenience function merge_validates_length_of_password_field_options to merge
         # options.</b>
         #
         # * <tt>Default:</tt> validates_length_of_password_field_options
         # * <tt>Accepts:</tt> Hash of options accepted by validates_length_of
         def validates_length_of_password_confirmation_field_options(value = nil)
-          rw_config(:validates_length_of_password_confirmation_field_options, value, validates_length_of_password_field_options)
+          rw_config(
+            :validates_length_of_password_confirmation_field_options,
+            value,
+            validates_length_of_password_field_options
+          )
         end
         alias_method :validates_length_of_password_confirmation_field_options=, :validates_length_of_password_confirmation_field_options
 
-        # See merge_validates_length_of_password_field_options. The same thing, except for validates_length_of_password_confirmation_field_options
+        # See merge_validates_length_of_password_field_options. The same thing, except for
+        # validates_length_of_password_confirmation_field_options
         def merge_validates_length_of_password_confirmation_field_options(options = {})
-          self.validates_length_of_password_confirmation_field_options = validates_length_of_password_confirmation_field_options.merge(options)
+          self.validates_length_of_password_confirmation_field_options =
+            validates_length_of_password_confirmation_field_options.merge(options)
         end
 
-        # The class you want to use to encrypt and verify your encrypted passwords. See the Authlogic::CryptoProviders module for more info
-        # on the available methods and how to create your own.
+        # The class you want to use to encrypt and verify your encrypted passwords. See
+        # the Authlogic::CryptoProviders module for more info on the available methods and
+        # how to create your own.
         #
         # * <tt>Default:</tt> CryptoProviders::SCrypt
         # * <tt>Accepts:</tt> Class
@@ -153,14 +182,17 @@ module Authlogic
         end
         alias_method :crypto_provider=, :crypto_provider
 
-        # Let's say you originally encrypted your passwords with Sha1. Sha1 is starting to join the party with MD5 and you want to switch
-        # to something stronger. No problem, just specify your new and improved algorithm with the crypt_provider option and then let
-        # Authlogic know you are transitioning from Sha1 using this option. Authlogic will take care of everything, including transitioning
-        # your users to the new algorithm. The next time a user logs in, they will be granted access using the old algorithm and their
-        # password will be resaved with the new algorithm. All new users will obviously use the new algorithm as well.
+        # Let's say you originally encrypted your passwords with Sha1. Sha1 is starting to
+        # join the party with MD5 and you want to switch to something stronger. No
+        # problem, just specify your new and improved algorithm with the crypt_provider
+        # option and then let Authlogic know you are transitioning from Sha1 using this
+        # option. Authlogic will take care of everything, including transitioning your
+        # users to the new algorithm. The next time a user logs in, they will be granted
+        # access using the old algorithm and their password will be resaved with the new
+        # algorithm. All new users will obviously use the new algorithm as well.
         #
-        # Lastly, if you want to transition again, you can pass an array of crypto providers. So you can transition from as many algorithms
-        # as you want.
+        # Lastly, if you want to transition again, you can pass an array of crypto
+        # providers. So you can transition from as many algorithms as you want.
         #
         # * <tt>Default:</tt> nil
         # * <tt>Accepts:</tt> Class or Array
@@ -194,6 +226,7 @@ module Authlogic
         end
 
         private
+
           METHODS.each do |method|
             class_eval <<-"end_eval", __FILE__, __LINE__
               def #{method}
@@ -230,23 +263,36 @@ module Authlogic
             @password
           end
 
-          # This is a virtual method. Once a password is passed to it, it will create new password salt as well as encrypt
-          # the password.
+          # This is a virtual method. Once a password is passed to it, it will
+          # create new password salt as well as encrypt the password.
           def password=(pass)
             return if ignore_blank_passwords? && pass.blank?
             before_password_set
             @password = pass
             send("#{password_salt_field}=", Authlogic::Random.friendly_token) if password_salt_field
-            send("#{crypted_password_field}=", crypto_provider.encrypt(*encrypt_arguments(@password, false, act_like_restful_authentication? ? :restful_authentication : nil)))
+            send(
+              "#{crypted_password_field}=",
+              crypto_provider.encrypt(
+                *encrypt_arguments(@password, false, act_like_restful_authentication? ? :restful_authentication : nil)
+              )
+            )
             @password_changed = true
             after_password_set
           end
 
-          # Accepts a raw password to determine if it is the correct password or not. Notice the second argument. That defaults to the value of
-          # check_passwords_against_database. See that method for more information, but basically it just tells Authlogic to check the password
-          # against the value in the database or the value in the object.
+          # Accepts a raw password to determine if it is the correct password or not.
+          # Notice the second argument. That defaults to the value of
+          # check_passwords_against_database. See that method for more information, but
+          # basically it just tells Authlogic to check the password against the value in
+          # the database or the value in the object.
           def valid_password?(attempted_password, check_against_database = check_passwords_against_database?)
-            crypted = check_against_database && send("#{crypted_password_field}_changed?") ? send("#{crypted_password_field}_was") : send(crypted_password_field)
+            crypted =
+              if check_against_database && send("#{crypted_password_field}_changed?")
+                send("#{crypted_password_field}_was")
+              else
+                send(crypted_password_field)
+              end
+
             return false if attempted_password.blank? || crypted.blank?
             before_password_verification
 
@@ -282,6 +328,7 @@ module Authlogic
           alias_method :randomize_password!, :reset_password!
 
           private
+
             def check_passwords_against_database?
               self.class.check_passwords_against_database == true
             end
@@ -292,7 +339,14 @@ module Authlogic
 
             def encrypt_arguments(raw_password, check_against_database, arguments_type = nil)
               salt = nil
-              salt = (check_against_database && send("#{password_salt_field}_changed?") ? send("#{password_salt_field}_was") : send(password_salt_field)) if password_salt_field
+              if password_salt_field
+                salt =
+                  if check_against_database && send("#{password_salt_field}_changed?")
+                    send("#{password_salt_field}_was")
+                  else
+                    send(password_salt_field)
+                  end
+              end
 
               case arguments_type
               when :restful_authentication
@@ -302,7 +356,7 @@ module Authlogic
               end
             end
 
-            # Determines if we need to tranisiton the password.
+            # Determines if we need to transition the password.
             # If the index > 0 then we are using an "transition from" crypto provider.
             # If the encryptor has a cost and the cost it outdated.
             # If we aren't using database values