authlogic 3.4.6 → 4.2.0

data/lib/authlogic/session/http_auth.rb

@@ -1,31 +1,35 @@
 module Authlogic
   module Session
-    # Handles all authentication that deals with basic HTTP auth. Which is authentication built into the HTTP protocol:
+    # Handles all authentication that deals with basic HTTP auth. Which is
+    # authentication built into the HTTP protocol:
     #
     #   http://username:password@whatever.com
     #
-    # Also, if you are not comfortable letting users pass their raw username and password you can always use the single
-    # access token. See Authlogic::Session::Params for more info.
+    # Also, if you are not comfortable letting users pass their raw username and
+    # password you can always use the single access token. See
+    # Authlogic::Session::Params for more info.
     module HttpAuth
       def self.included(klass)
         klass.class_eval do
           extend Config
           include InstanceMethods
-          persist :persist_by_http_auth, :if => :persist_by_http_auth?
+          persist :persist_by_http_auth, if: :persist_by_http_auth?
         end
       end
-      
+
       # Configuration for the HTTP basic auth feature of Authlogic.
       module Config
         # Do you want to allow your users to log in via HTTP basic auth?
         #
-        # I recommend keeping this enabled. The only time I feel this should be disabled is if you are not comfortable
-        # having your users provide their raw username and password. Whatever the reason, you can disable it here.
+        # I recommend keeping this enabled. The only time I feel this should be
+        # disabled is if you are not comfortable having your users provide their
+        # raw username and password. Whatever the reason, you can disable it
+        # here.
         #
         # * <tt>Default:</tt> true
         # * <tt>Accepts:</tt> Boolean
         def allow_http_basic_auth(value = nil)
-          rw_config(:allow_http_basic_auth, value, true)
+          rw_config(:allow_http_basic_auth, value, false)
         end
         alias_method :allow_http_basic_auth=, :allow_http_basic_auth
 
@@ -60,39 +64,43 @@ module Authlogic
         # * <tt>Default:</tt> 'Application'
         # * <tt>Accepts:</tt> String
         def http_basic_auth_realm(value = nil)
-          rw_config(:http_basic_auth_realm, value, 'Application')
+          rw_config(:http_basic_auth_realm, value, "Application")
         end
         alias_method :http_basic_auth_realm=, :http_basic_auth_realm
       end
-      
+
       # Instance methods for the HTTP basic auth feature of authlogic.
       module InstanceMethods
         private
-          def persist_by_http_auth?
-            allow_http_basic_auth? && login_field && password_field
-          end
-        
-          def persist_by_http_auth
-            login_proc = Proc.new do |login, password|
-              if !login.blank? && !password.blank?
-                send("#{login_field}=", login)
-                send("#{password_field}=", password)
-                valid?
-              end
-            end
 
-            if self.class.request_http_basic_auth
-              controller.authenticate_or_request_with_http_basic(self.class.http_basic_auth_realm, &login_proc)
-            else
-              controller.authenticate_with_http_basic(&login_proc)
+        def persist_by_http_auth?
+          allow_http_basic_auth? && login_field && password_field
+        end
+
+        def persist_by_http_auth
+          login_proc = proc do |login, password|
+            if !login.blank? && !password.blank?
+              send("#{login_field}=", login)
+              send("#{password_field}=", password)
+              valid?
             end
-        
-            false
           end
-        
-          def allow_http_basic_auth?
-            self.class.allow_http_basic_auth == true
+
+          if self.class.request_http_basic_auth
+            controller.authenticate_or_request_with_http_basic(
+              self.class.http_basic_auth_realm,
+              &login_proc
+            )
+          else
+            controller.authenticate_with_http_basic(&login_proc)
           end
+
+          false
+        end
+
+        def allow_http_basic_auth?
+          self.class.allow_http_basic_auth == true
+        end
       end
     end
   end

data/lib/authlogic/session/id.rb

@@ -1,41 +1,53 @@
 module Authlogic
   module Session
-    # Allows you to separate sessions with an id, ultimately letting you create multiple sessions for the same user.
+    # Allows you to separate sessions with an id, ultimately letting you create
+    # multiple sessions for the same user.
     module Id
+      def initialize(*args)
+        @id = nil
+        super
+      end
+
       def self.included(klass)
         klass.class_eval do
           attr_writer :id
         end
       end
-      
+
       # Setting the id if it is passed in the credentials.
       def credentials=(value)
         super
         values = value.is_a?(Array) ? value : [value]
         self.id = values.last if values.last.is_a?(Symbol)
       end
-      
-      # Allows you to set a unique identifier for your session, so that you can have more than 1 session at a time.
-      # A good example when this might be needed is when you want to have a normal user session and a "secure" user session.
-      # The secure user session would be created only when they want to modify their billing information, or other sensitive
-      # information. Similar to me.com. This requires 2 user sessions. Just use an id for the "secure" session and you should be good.
+
+      # Allows you to set a unique identifier for your session, so that you can
+      # have more than 1 session at a time. A good example when this might be
+      # needed is when you want to have a normal user session and a "secure"
+      # user session. The secure user session would be created only when they
+      # want to modify their billing information, or other sensitive
+      # information. Similar to me.com. This requires 2 user sessions. Just use
+      # an id for the "secure" session and you should be good.
       #
-      # You can set the id during initialization (see initialize for more information), or as an attribute:
+      # You can set the id during initialization (see initialize for more
+      # information), or as an attribute:
       #
       #   session.id = :my_id
       #
       # Just be sure and set your id before you save your session.
       #
-      # Lastly, to retrieve your session with the id check out the find class method.
+      # Lastly, to retrieve your session with the id check out the find class
+      # method.
       def id
         @id
       end
-      
+
       private
-        # Used for things like cookie_key, session_key, etc.
-        def build_key(last_part)
-          [id, super].compact.join("_")
-        end
+
+      # Used for things like cookie_key, session_key, etc.
+      def build_key(last_part)
+        [id, super].compact.join("_")
+      end
     end
   end
-end
+end

data/lib/authlogic/session/klass.rb

@@ -16,7 +16,8 @@ module Authlogic
       module Config
         # Lets you change which model to use for authentication.
         #
-        # * <tt>Default:</tt> inferred from the class name. UserSession would automatically try User
+        # * <tt>Default:</tt> inferred from the class name. UserSession would
+        #   automatically try User
         # * <tt>Accepts:</tt> an ActiveRecord class
         def authenticate_with(klass)
           @klass_name = klass.name
@@ -24,9 +25,10 @@ module Authlogic
         end
         alias_method :authenticate_with=, :authenticate_with
 
-        # The name of the class that this session is authenticating with. For example, the UserSession class will
-        # authenticate with the User class unless you specify otherwise in your configuration. See authenticate_with
-        # for information on how to change this value.
+        # The name of the class that this session is authenticating with. For
+        # example, the UserSession class will authenticate with the User class
+        # unless you specify otherwise in your configuration. See
+        # authenticate_with for information on how to change this value.
         def klass
           @klass ||= klass_name ? klass_name.constantize : nil
         end
@@ -40,7 +42,8 @@ module Authlogic
       end
 
       module InstanceMethods
-        # Creating an alias method for the "record" method based on the klass name, so that we can do:
+        # Creating an alias method for the "record" method based on the klass
+        # name, so that we can do:
         #
         #   session.user
         #
@@ -48,7 +51,7 @@ module Authlogic
         #
         #   session.record
         def initialize(*args)
-          if !self.class.configured_klass_methods
+          unless self.class.configured_klass_methods
             self.class.send(:alias_method, klass_name.demodulize.underscore.to_sym, :record)
             self.class.configured_klass_methods = true
           end
@@ -56,14 +59,15 @@ module Authlogic
         end
 
         private
-          def klass
-            self.class.klass
-          end
 
-          def klass_name
-            self.class.klass_name
-          end
+        def klass
+          self.class.klass
+        end
+
+        def klass_name
+          self.class.klass_name
+        end
       end
     end
   end
-end
+end

data/lib/authlogic/session/magic_columns.rb

@@ -1,33 +1,39 @@
 module Authlogic
   module Session
-    # Just like ActiveRecord has "magic" columns, such as: created_at and updated_at. Authlogic has its own "magic" columns too:
+    # Just like ActiveRecord has "magic" columns, such as: created_at and updated_at.
+    # Authlogic has its own "magic" columns too:
     #
-    #   Column name           Description
-    #   login_count           Increased every time an explicit login is made. This will *NOT* increase if logging in by a session, cookie, or basic http auth
-    #   failed_login_count    This increases for each consecutive failed login. See Authlogic::Session::BruteForceProtection and the consecutive_failed_logins_limit config option for more details.
-    #   last_request_at       Updates every time the user logs in, either by explicitly logging in, or logging in by cookie, session, or http auth
-    #   current_login_at      Updates with the current time when an explicit login is made.
-    #   last_login_at         Updates with the value of current_login_at before it is reset.
-    #   current_login_ip      Updates with the request ip when an explicit login is made.
-    #   last_login_ip         Updates with the value of current_login_ip before it is reset.
+    # * login_count - Increased every time an explicit login is made. This will *NOT*
+    #   increase if logging in by a session, cookie, or basic http auth
+    # * failed_login_count - This increases for each consecutive failed login. See
+    #   Authlogic::Session::BruteForceProtection and the consecutive_failed_logins_limit
+    #   config option for more details.
+    # * last_request_at - Updates every time the user logs in, either by explicitly
+    #   logging in, or logging in by cookie, session, or http auth
+    # * current_login_at - Updates with the current time when an explicit login is made.
+    # * last_login_at - Updates with the value of current_login_at before it is reset.
+    # * current_login_ip - Updates with the request ip when an explicit login is made.
+    # * last_login_ip - Updates with the value of current_login_ip before it is reset.
     module MagicColumns
       def self.included(klass)
         klass.class_eval do
           extend Config
           include InstanceMethods
-          after_persisting :set_last_request_at, :if => :set_last_request_at?
+          after_persisting :set_last_request_at, if: :set_last_request_at?
           validate :increase_failed_login_count
           before_save :update_info
-          before_save :set_last_request_at, :if => :set_last_request_at?
+          before_save :set_last_request_at, if: :set_last_request_at?
         end
       end
 
       # Configuration for the magic columns feature.
       module Config
-        # Every time a session is found the last_request_at field for that record is updated with the current time, if that field exists.
-        # If you want to limit how frequent that field is updated specify the threshold here. For example, if your user is making a
-        # request every 5 seconds, and you feel this is too frequent, and feel a minute is a good threshold. Set this to 1.minute.
-        # Once a minute has passed in between requests the field will be updated.
+        # Every time a session is found the last_request_at field for that record is
+        # updated with the current time, if that field exists. If you want to limit how
+        # frequent that field is updated specify the threshold here. For example, if your
+        # user is making a request every 5 seconds, and you feel this is too frequent, and
+        # feel a minute is a good threshold. Set this to 1.minute. Once a minute has
+        # passed in between requests the field will be updated.
         #
         # * <tt>Default:</tt> 0
         # * <tt>Accepts:</tt> integer representing time in seconds
@@ -37,63 +43,76 @@ module Authlogic
         alias_method :last_request_at_threshold=, :last_request_at_threshold
       end
 
-      # The methods available for an Authlogic::Session::Base object that make up the magic columns feature.
+      # The methods available for an Authlogic::Session::Base object that make
+      # up the magic columns feature.
       module InstanceMethods
         private
-          def increase_failed_login_count
-            if invalid_password? && attempted_record.respond_to?(:failed_login_count)
-              attempted_record.failed_login_count ||= 0
-              attempted_record.failed_login_count += 1
-            end
+
+        def clear_failed_login_count
+          if record.respond_to?(:failed_login_count)
+            record.failed_login_count = 0
           end
+        end
 
-          def update_info
-            if record.respond_to?(:login_count)
-              record.login_count = (record.login_count.blank? ? 1 : record.login_count + 1)
-            end
+        def increase_failed_login_count
+          if invalid_password? && attempted_record.respond_to?(:failed_login_count)
+            attempted_record.failed_login_count ||= 0
+            attempted_record.failed_login_count += 1
+          end
+        end
 
-            if record.respond_to?(:failed_login_count)
-              record.failed_login_count = 0
-            end
+        def increment_login_cout
+          if record.respond_to?(:login_count)
+            record.login_count = (record.login_count.blank? ? 1 : record.login_count + 1)
+          end
+        end
 
-            if record.respond_to?(:current_login_at)
-              record.last_login_at = record.current_login_at if record.respond_to?(:last_login_at)
-              record.current_login_at = klass.default_timezone == :utc ? Time.now.utc : Time.now
-            end
+        def update_info
+          increment_login_cout
+          clear_failed_login_count
+          update_login_timestamps
+          update_login_ip_addresses
+        end
 
-            if record.respond_to?(:current_login_ip)
-              record.last_login_ip = record.current_login_ip if record.respond_to?(:last_login_ip)
-              record.current_login_ip = controller.request.ip
-            end
+        def update_login_ip_addresses
+          if record.respond_to?(:current_login_ip)
+            record.last_login_ip = record.current_login_ip if record.respond_to?(:last_login_ip)
+            record.current_login_ip = controller.request.ip
           end
+        end
 
-          # This method lets authlogic know whether it should allow the last_request_at field to be updated
-          # with the current time (Time.now). One thing to note here is that it also checks for the existence of a
-          # last_request_update_allowed? method in your controller. This allows you to control this method pragmatically
-          # in your controller.
-          #
-          # For example, what if you had a javascript function that polled the server updating how much time is left in their
-          # session before it times out. Obviously you would want to ignore this request, because then the user would never time out.
-          # So you can do something like this in your controller:
-          #
-          #   def last_request_update_allowed?
-          #     action_name != "update_session_time_left"
-          #   end
-          #
-          # You can do whatever you want with that method.
-          def set_last_request_at? # :doc:
-            return false if !record || !klass.column_names.include?("last_request_at")
-            return controller.last_request_update_allowed? if controller.responds_to_last_request_update_allowed?
-            record.last_request_at.blank? || last_request_at_threshold.to_i.seconds.ago >= record.last_request_at
+        def update_login_timestamps
+          if record.respond_to?(:current_login_at)
+            record.last_login_at = record.current_login_at if record.respond_to?(:last_login_at)
+            record.current_login_at = klass.default_timezone == :utc ? Time.now.utc : Time.now
           end
+        end
 
-          def set_last_request_at
-            record.last_request_at = klass.default_timezone == :utc ? Time.now.utc : Time.now
+        # This method lets authlogic know whether it should allow the
+        # last_request_at field to be updated with the current time.
+        #
+        # See also `last_request_update_allowed?` in
+        # `Authlogic::ControllerAdapters::AbstractAdapter`
+        #
+        # @api private
+        def set_last_request_at?
+          if !record || !klass.column_names.include?("last_request_at")
+            return false
           end
-
-          def last_request_at_threshold
-            self.class.last_request_at_threshold
+          unless controller.last_request_update_allowed?
+            return false
           end
+          record.last_request_at.blank? ||
+            last_request_at_threshold.to_i.seconds.ago >= record.last_request_at
+        end
+
+        def set_last_request_at
+          record.last_request_at = klass.default_timezone == :utc ? Time.now.utc : Time.now
+        end
+
+        def last_request_at_threshold
+          self.class.last_request_at_threshold
+        end
       end
     end
   end

data/lib/authlogic/session/magic_states.rb

@@ -1,32 +1,41 @@
 module Authlogic
   module Session
-    # Authlogic tries to check the state of the record before creating the session. If your record responds to the following methods and any of them return false, validation will fail:
+    # Authlogic tries to check the state of the record before creating the session. If
+    # your record responds to the following methods and any of them return false,
+    # validation will fail:
     #
     #   Method name           Description
     #   active?               Is the record marked as active?
     #   approved?             Has the record been approved?
-    #   confirmed?            Has the record been conirmed?
+    #   confirmed?            Has the record been confirmed?
     #
-    # Authlogic does nothing to define these methods for you, its up to you to define what they mean. If your object responds to these methods Authlogic will use them, otherwise they are ignored.
+    # Authlogic does nothing to define these methods for you, its up to you to define what
+    # they mean. If your object responds to these methods Authlogic will use them,
+    # otherwise they are ignored.
     #
-    # What's neat about this is that these are checked upon any type of login. When logging in explicitly, by cookie, session, or basic http auth.
-    # So if you mark a user inactive in the middle of their session they wont be logged back in next time they refresh the page. Giving you complete control.
+    # What's neat about this is that these are checked upon any type of login. When
+    # logging in explicitly, by cookie, session, or basic http auth. So if you mark a user
+    # inactive in the middle of their session they wont be logged back in next time they
+    # refresh the page. Giving you complete control.
     #
-    # Need Authlogic to check your own "state"? No problem, check out the hooks section below. Add in a before_validation to do your own checking. The sky is the limit.
+    # Need Authlogic to check your own "state"? No problem, check out the hooks section
+    # below. Add in a before_validation to do your own checking. The sky is the limit.
     module MagicStates
       def self.included(klass)
         klass.class_eval do
           extend Config
           include InstanceMethods
-          validate :validate_magic_states, :unless => :disable_magic_states?
+          validate :validate_magic_states, unless: :disable_magic_states?
         end
       end
-      
+
       # Configuration for the magic states feature.
       module Config
-        # Set this to true if you want to disable the checking of active?, approved?, and confirmed? on your record. This is more or less of a
-        # convenience feature, since 99% of the time if those methods exist and return false you will not want the user logging in. You could
-        # easily accomplish this same thing with a before_validation method or other callbacks.
+        # Set this to true if you want to disable the checking of active?, approved?, and
+        # confirmed? on your record. This is more or less of a convenience feature, since
+        # 99% of the time if those methods exist and return false you will not want the
+        # user logging in. You could easily accomplish this same thing with a
+        # before_validation method or other callbacks.
         #
         # * <tt>Default:</tt> false
         # * <tt>Accepts:</tt> Boolean
@@ -35,25 +44,39 @@ module Authlogic
         end
         alias_method :disable_magic_states=, :disable_magic_states
       end
-      
-      # The methods available for an Authlogic::Session::Base object that make up the magic states feature.
+
+      # The methods available for an Authlogic::Session::Base object that make up the
+      # magic states feature.
       module InstanceMethods
         private
-          def disable_magic_states?
-            self.class.disable_magic_states == true
-          end
-        
-          def validate_magic_states
-            return true if attempted_record.nil?
-            [:active, :approved, :confirmed].each do |required_status|
-              if attempted_record.respond_to?("#{required_status}?") && !attempted_record.send("#{required_status}?")
-                errors.add(:base, I18n.t("error_messages.not_#{required_status}", :default => "Your account is not #{required_status}"))
-                return false
-              end
-            end
-            true
+
+        def disable_magic_states?
+          self.class.disable_magic_states == true
+        end
+
+        # @api private
+        def required_magic_states_for(record)
+          %i[active approved confirmed].select { |state|
+            record.respond_to?("#{state}?")
+          }
+        end
+
+        def validate_magic_states
+          return true if attempted_record.nil?
+          required_magic_states_for(attempted_record).each do |required_status|
+            next if attempted_record.send("#{required_status}?")
+            errors.add(
+              :base,
+              I18n.t(
+                "error_messages.not_#{required_status}",
+                default: "Your account is not #{required_status}"
+              )
+            )
+            return false
           end
+          true
+        end
       end
     end
   end
-end
+end