authlogic 2.1.11 → 3.0.0

data/lib/authlogic/acts_as_authentic/logged_in_status.rb

@@ -32,8 +32,8 @@ module Authlogic
           klass.class_eval do
             include InstanceMethods
             
-            named_scope :logged_in, lambda { {:conditions => ["last_request_at > ?", logged_in_timeout.seconds.ago]} }
-            named_scope :logged_out, lambda { {:conditions => ["last_request_at is NULL or last_request_at <= ?", logged_in_timeout.seconds.ago]} }
+            scope :logged_in, lambda { {:conditions => ["last_request_at > ?", logged_in_timeout.seconds.ago]} }
+            scope :logged_out, lambda { {:conditions => ["last_request_at is NULL or last_request_at <= ?", logged_in_timeout.seconds.ago]} }
           end
         end
         

data/lib/authlogic/acts_as_authentic/login.rb

@@ -8,7 +8,7 @@ module Authlogic
           add_acts_as_authentic_module(Methods)
         end
       end
-      
+
       # Confguration for the login field.
       module Config
         # The name of the login field in the database.
@@ -19,7 +19,7 @@ module Authlogic
           rw_config(:login_field, value, first_column_to_exist(nil, :login, :username))
         end
         alias_method :login_field=, :login_field
-        
+
         # Whether or not the validate the login field
         #
         # * <tt>Default:</tt> true
@@ -28,7 +28,7 @@ module Authlogic
           rw_config(:validate_login_field, value, true)
         end
         alias_method :validate_login_field=, :validate_login_field
-        
+
         # A hash of options for the validates_length_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
@@ -41,7 +41,7 @@ module Authlogic
           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
-        
+
         # A convenience function to merge options into the validates_length_of_login_field_options. So intead of:
         #
         #   self.validates_length_of_login_field_options = validates_length_of_login_field_options.merge(:my_option => my_value)
@@ -52,25 +52,25 @@ module Authlogic
         def merge_validates_length_of_login_field_options(options = {})
           self.validates_length_of_login_field_options = validates_length_of_login_field_options.merge(options)
         end
-        
+
         # A hash of options for the validates_format_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>
         #
-        # * <tt>Default:</tt> {:with => Authlogic::Regex.login, :message => 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.")})
         end
         alias_method :validates_format_of_login_field_options=, :validates_format_of_login_field_options
-        
+
         # See merge_validates_length_of_login_field_options. The same thing, except for validates_format_of_login_field_options
         def merge_validates_format_of_login_field_options(options = {})
           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.
         #
         # <b>Keep in mind this is ruby. I wanted to keep this as flexible as possible, so you can completely replace the hash or
@@ -83,18 +83,18 @@ module Authlogic
           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
-        
+
         # See merge_validates_length_of_login_field_options. The same thing, except for validates_uniqueness_of_login_field_options
         def merge_validates_uniqueness_of_login_field_options(options = {})
           self.validates_uniqueness_of_login_field_options = validates_uniqueness_of_login_field_options.merge(options)
         end
-        
+
         # This method allows you to find a record with the given login. If you notice, with ActiveRecord you have the
         # validates_uniqueness_of validation function. They give you a :case_sensitive option. I handle this in the same
         # manner that they handle that. If you are using the login field and set false for the :case_sensitive option in
         # validates_uniqueness_of_login_field_options this method will modify the query to look something like:
         #
-        #   first(:conditions => ["LOWER(#{quoted_table_name}.#{login_field}) = ?", login.downcase])
+        #   where("LOWER(#{quoted_table_name}.#{login_field}) = ?", login.downcase).first
         #
         # If you don't specify this it calls the good old find_by_* method:
         #
@@ -112,17 +112,17 @@ module Authlogic
             find_with_case(email_field, login, validates_uniqueness_of_email_field_options[:case_sensitive] != false)
           end
         end
-        
+
         private
           def find_with_case(field, value, sensitivity = true)
             if sensitivity
               send("find_by_#{field}", value)
             else
-              first(:conditions => ["LOWER(#{quoted_table_name}.#{field}) = ?", value.mb_chars.downcase])
+              where("LOWER(#{quoted_table_name}.#{field}) = ?", value.mb_chars.downcase).first
             end
           end
       end
-      
+
       # All methods relating to the login field
       module Methods
         # Adds in various validations, modules, etc.

data/lib/authlogic/acts_as_authentic/password.rb

@@ -277,7 +277,7 @@ module Authlogic
           # Resets the password to a random friendly token and then saves the record.
           def reset_password!
             reset_password
-            save_without_session_maintenance(false)
+            save_without_session_maintenance(:validate => false)
           end
           alias_method :randomize_password!, :reset_password!
         
@@ -314,7 +314,7 @@ module Authlogic
             
             def transition_password(attempted_password)
               self.password = attempted_password
-              save(false)
+              save(:validate => false)
             end
           
             def require_password?

data/lib/authlogic/acts_as_authentic/perishable_token.rb

@@ -11,7 +11,7 @@ module Authlogic
           add_acts_as_authentic_module(Methods)
         end
       end
-
+      
       # Change how the perishable token works.
       module Config
         # When using the find_using_perishable_token method the token can expire. If the token is expired, no
@@ -23,7 +23,7 @@ module Authlogic
           rw_config(:perishable_token_valid_for, (!value.nil? && value.to_i) || value, 10.minutes.to_i)
         end
         alias_method :perishable_token_valid_for=, :perishable_token_valid_for
-
+        
         # Authlogic tries to expire and change the perishable token as much as possible, without comprising
         # it's purpose. This is for security reasons. If you want to manage it yourself, you can stop
         # Authlogic from getting your in way by setting this to true.
@@ -35,21 +35,21 @@ module Authlogic
         end
         alias_method :disable_perishable_token_maintenance=, :disable_perishable_token_maintenance
       end
-
+      
       # All methods relating to the perishable token.
       module Methods
         def self.included(klass)
           return if !klass.column_names.include?("perishable_token")
-
+          
           klass.class_eval do
             extend ClassMethods
             include InstanceMethods
-
+            
             validates_uniqueness_of :perishable_token, :if => :perishable_token_changed?
             before_save :reset_perishable_token, :unless => :disable_perishable_token_maintenance?
           end
         end
-
+        
         # Class level methods for the perishable token
         module ClassMethods
           # Use this methdo to find a record with a perishable token. This method does 2 things for you:
@@ -63,37 +63,37 @@ module Authlogic
           def find_using_perishable_token(token, age = self.perishable_token_valid_for)
             return if token.blank?
             age = age.to_i
-
+            
             conditions_sql = "perishable_token = ?"
-            conditions_subs = [token.to_s]
-
+            conditions_subs = [token]
+            
             if column_names.include?("updated_at") && age > 0
               conditions_sql += " and updated_at > ?"
               conditions_subs << age.seconds.ago
             end
-
+            
             find(:first, :conditions => [conditions_sql, *conditions_subs])
           end
-
+          
           # This method will raise ActiveRecord::NotFound if no record is found.
           def find_using_perishable_token!(token, age = perishable_token_valid_for)
             find_using_perishable_token(token, age) || raise(ActiveRecord::RecordNotFound)
           end
         end
-
+        
         # Instance level methods for the perishable token.
         module InstanceMethods
           # Resets the perishable token to a random friendly token.
           def reset_perishable_token
             self.perishable_token = Random.friendly_token
           end
-
+          
           # Same as reset_perishable_token, but then saves the record afterwards.
           def reset_perishable_token!
             reset_perishable_token
-            save_without_session_maintenance(false)
+            save_without_session_maintenance(:validate => false)
           end
-
+          
           # A convenience method based on the disable_perishable_token_maintenance configuration option.
           def disable_perishable_token_maintenance?
             self.class.disable_perishable_token_maintenance == true

data/lib/authlogic/acts_as_authentic/persistence_token.rb

@@ -53,7 +53,7 @@ module Authlogic
           # Same as reset_persistence_token, but then saves the record.
           def reset_persistence_token!
             reset_persistence_token
-            save_without_session_maintenance(false)
+            save_without_session_maintenance(:validate => false)
           end
           alias_method :forget!, :reset_persistence_token!
           

data/lib/authlogic/acts_as_authentic/session_maintenance.rb

@@ -48,25 +48,12 @@ module Authlogic
         end
         alias_method :session_ids=, :session_ids
         
-        # In some cases, you can use a different namespace for the session class. If you want to use a model
-        # to control access in a namespace and edit it in another namespace, you can define the session class
-        # namespace here so authlogic knows where to find it without problems.
-        #
-        # * <tt>Default:</tt> nil
-        # * <tt>Accepts:</tt> Strings
-        def session_class_namespace(value = nil)
-          rw_config(:session_class_namespace, value, nil)
-        end
-        alias_method :session_class_namespace=, :session_class_namespace
-        
         # The name of the associated session class. This is inferred by the name of the model.
         #
         # * <tt>Default:</tt> "#{klass.name}Session".constantize
         # * <tt>Accepts:</tt> Class
         def session_class(value = nil)
-          namespace = rw_config(:session_class_namespace, nil)
-
-          const = ((namespace.nil? ? "" : "#{namespace}::") + "#{base_class.name}Session").constantize rescue nil
+          const = "#{base_class.name}Session".constantize rescue nil
           rw_config(:session_class, value, const)
         end
         alias_method :session_class=, :session_class
@@ -149,4 +136,4 @@ module Authlogic
       end
     end
   end
-end
+end

data/lib/authlogic/authenticates_many/base.rb

@@ -23,7 +23,7 @@ module Authlogic
       #
       # * <tt>session_class:</tt> default: "#{name}Session",
       #   This is the related session class.
-      #   
+      #
       # * <tt>relationship_name:</tt> default: options[:session_class].klass_name.underscore.pluralize,
       #   This is the name of the relationship you want to use to scope everything. For example an Account has many Users. There should be a relationship
       #   called :users that you defined with a has_many. The reason we use the relationship is so you don't have to repeat yourself. The relatonship
@@ -42,14 +42,13 @@ module Authlogic
         options[:relationship_name] ||= options[:session_class].klass_name.underscore.pluralize
         class_eval <<-"end_eval", __FILE__, __LINE__
           def #{name}
-            find_options = #{options[:find_options].inspect} || #{options[:relationship_name]}.scope(:find)
-            find_options.delete_if { |key, value| ![:conditions, :include, :joins].include?(key.to_sym) || value.nil? }
+            find_options = #{options[:find_options].inspect} || #{options[:relationship_name]}.scoped
             @#{name} ||= Authlogic::AuthenticatesMany::Association.new(#{options[:session_class]}, find_options, #{options[:scope_cookies] ? "self.class.model_name.underscore + '_' + self.send(self.class.primary_key).to_s" : "nil"})
           end
         end_eval
       end
     end
-    
+
     ::ActiveRecord::Base.extend(Base) if defined?(::ActiveRecord)
   end
 end

data/lib/authlogic/controller_adapters/sinatra_adapter.rb

@@ -58,4 +58,4 @@ module Authlogic
   end
 end
 
-Sinatra::Base.send(:include, Authlogic::ControllerAdapters::SinatraAdapter::Adapter::Implementation)
+Sinatra::Request.send(:include, Authlogic::ControllerAdapters::SinatraAdapter::Adapter::Implementation)

data/lib/authlogic/regex.rb

@@ -9,18 +9,17 @@ module Authlogic
     # by reading this website: http://www.regular-expressions.info/email.html, which is an excellent resource
     # for regular expressions.
     def self.email
-      @email_regex ||= begin
-        email_name_regex  = '[A-Z0-9_\.%\+\-\']+'
-        domain_head_regex = '(?:[A-Z0-9\-]+\.)+'
-        domain_tld_regex  = '(?:[A-Z]{2,4}|museum|travel)'
-        /\A#{email_name_regex}@#{domain_head_regex}#{domain_tld_regex}\z/i
-      end
+      return @email_regex if @email_regex
+      email_name_regex  = '[A-Z0-9_\.%\+\-\']+'
+      domain_head_regex = '(?:[A-Z0-9\-]+\.)+'
+      domain_tld_regex  = '(?:[A-Z]{2,4}|museum|travel)'
+      @email_regex = /^#{email_name_regex}@#{domain_head_regex}#{domain_tld_regex}$/i
     end
-
+    
     # A simple regular expression that only allows for letters, numbers, spaces, and .-_@. Just a standard login / username
     # regular expression.
     def self.login
-      /\A\w[\w\.+\-_@ ]+\z/
+      /\A\w[\w\.+\-_@ ]+$/
     end
   end
-end
+end

data/lib/authlogic/session/active_record_trickery.rb

@@ -40,12 +40,20 @@ module Authlogic
         
         # For rails >= 3.0
         def model_name
-          if defined?(::ActiveModel.version)
+          if defined?(::ActiveModel)
             ::ActiveModel::Name.new(self)
           else
             ::ActiveSupport::ModelName.new(self.to_s)
           end
         end
+
+        def i18n_scope
+          I18n.scope
+        end
+
+        def lookup_ancestors
+          ancestors.select { |x| x.respond_to?(:model_name) }
+        end
       end
       
       module InstanceMethods

data/lib/authlogic/session/callbacks.rb

@@ -92,7 +92,7 @@ module Authlogic
         
         def save_record(alternate_record = nil)
           r = alternate_record || record
-          r.save_without_session_maintenance(false) if r && r.changed? && !r.readonly?
+          r.save_without_session_maintenance(:validate => false) if r && r.changed? && !r.readonly?
         end
     end
   end

data/lib/authlogic/session/cookies.rb

@@ -11,7 +11,7 @@ module Authlogic
           after_destroy :destroy_cookie
         end
       end
-
+      
       # Configuration for the cookie feature set.
       module Config
         # The name of the cookie or the key in the cookies hash. Be sure and use a unique name. If you have multiple sessions and they use the same cookie it will cause problems.
@@ -19,7 +19,7 @@ module Authlogic
         #
         #   session = UserSession.new
         #   session.cookie_key => "user_credentials"
-        #
+        #   
         #   session = UserSession.new(:super_high_secret)
         #   session.cookie_key => "super_high_secret_user_credentials"
         #
@@ -29,7 +29,7 @@ module Authlogic
           rw_config(:cookie_key, value, "#{guessed_klass_name.underscore}_credentials")
         end
         alias_method :cookie_key=, :cookie_key
-
+        
         # If sessions should be remembered by default or not.
         #
         # * <tt>Default:</tt> false
@@ -38,7 +38,7 @@ module Authlogic
           rw_config(:remember_me, value, false)
         end
         alias_method :remember_me=, :remember_me
-
+        
         # The length of time until the cookie expires.
         #
         # * <tt>Default:</tt> 3.months
@@ -66,7 +66,7 @@ module Authlogic
         end
         alias_method :httponly=, :httponly
       end
-
+      
       # The methods available for an Authlogic::Session::Base object that make up the cookie feature set.
       module InstanceMethods
         # Allows you to set the remember_me option when passing credentials.
@@ -81,29 +81,29 @@ module Authlogic
             self.remember_me = r if !r.nil?
           end
         end
-
+        
         # Is the cookie going to expire after the session is over, or will it stick around?
         def remember_me
           return @remember_me if defined?(@remember_me)
           @remember_me = self.class.remember_me
         end
-
+        
         # Accepts a boolean as a flag to remember the session or not. Basically to expire the cookie at the end of the session or keep it for "remember_me_until".
         def remember_me=(value)
           @remember_me = value
         end
-
+        
         # See remember_me
         def remember_me?
           remember_me == true || remember_me == "true" || remember_me == "1"
         end
-
+        
         # How long to remember the user if remember_me is true. This is based on the class level configuration: remember_me_for
         def remember_me_for
           return unless remember_me?
           self.class.remember_me_for
         end
-
+        
         # When to expire the cookie. See remember_me_for configuration option to change this.
         def remember_me_until
           return unless remember_me?
@@ -146,15 +146,15 @@ module Authlogic
           def cookie_key
             build_key(self.class.cookie_key)
           end
-
+          
           def cookie_credentials
             controller.cookies[cookie_key] && controller.cookies[cookie_key].split("::")
           end
-
+          
           # Tries to validate the session from information in the cookie
           def persist_by_cookie
             persistence_token, record_id = cookie_credentials
-            if !persistence_token.blank?
+            if !persistence_token.nil?
               record = record_id.nil? ? search_for_record("find_by_persistence_token", persistence_token) : search_for_record("find_by_#{klass.primary_key}", record_id)
               self.unauthorized_record = record if record && record.persistence_token == persistence_token
               valid?
@@ -162,7 +162,7 @@ module Authlogic
               false
             end
           end
-
+          
           def save_cookie
             controller.cookies[cookie_key] = {
               :value => "#{record.persistence_token}::#{record.send(record.class.primary_key)}",
@@ -172,7 +172,7 @@ module Authlogic
               :domain => controller.cookie_domain
             }
           end
-
+          
           def destroy_cookie
             controller.cookies.delete cookie_key, :domain => controller.cookie_domain
           end