authlogic 3.8.0 → 6.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 755961398552a88cf3761088e4521e71e243249b3a131632e281679d723c82fe
+  data.tar.gz: 2b739ad482ecdaad8218065a4c03882e730c86825bc7140691e451fc26032815
+SHA512:
+  metadata.gz: 52e998e1210ac287f2bc91d01d2afba9416f5b0eee54cff13d89c6c9affdd2ff2a88ac1a80e78ce100c2a43dcbcf777a5f22dd3d72ff3571bc69c5242a89d97c
+  data.tar.gz: 6152232cf873d2c9be4fa24584b3d8bf8013f95ae58a8117f4494c3a6632df814e36b85d02c67efc0e2b73849a43333c0b9bcf9cb1d379f10587147aa69f808e

data/lib/authlogic/acts_as_authentic/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Authlogic
   module ActsAsAuthentic
     # Provides the base functionality for acts_as_authentic
@@ -11,11 +13,13 @@ module Authlogic
         end
       end
 
+      # The primary configuration of a model (often, `User`) for use with
+      # authlogic. These methods become class methods of ::ActiveRecord::Base.
       module Config
-        # This includes a lot of helpful methods for authenticating records which The Authlogic::Session module relies on.
-        # To use it just do:
+        # This includes a lot of helpful methods for authenticating records
+        # which the Authlogic::Session module relies on. To use it just do:
         #
-        #   class User < ActiveRecord::Base
+        #   class User < ApplicationRecord
         #     acts_as_authentic
         #   end
         #
@@ -26,29 +30,21 @@ module Authlogic
         #   end
         #
         # See the various sub modules for the configuration they provide.
-        def acts_as_authentic(unsupported_options = nil, &block)
-          # Stop all configuration if the DB is not set up
-          return if !db_setup?
-
-          if !unsupported_options.nil?
-            raise ArgumentError.new(
-              "You are using the old v1.X.X configuration method for " \
-                "Authlogic. Instead of passing a hash of configuration " \
-                "options to acts_as_authentic, pass a block: " \
-                "acts_as_authentic { |c| c.my_option = my_value }"
-            )
-          end
-
+        def acts_as_authentic
+          return unless db_setup?
           yield self if block_given?
           acts_as_authentic_modules.each { |mod| include mod }
         end
 
-        # Since this part of Authlogic deals with another class, ActiveRecord, we can't just start including things
-        # in ActiveRecord itself. A lot of these module includes need to be triggered by the acts_as_authentic method
-        # call. For example, you don't want to start adding in email validations and what not into a model that has
-        # nothing to do with Authlogic.
+        # Since this part of Authlogic deals with another class, ActiveRecord,
+        # we can't just start including things in ActiveRecord itself. A lot of
+        # these module includes need to be triggered by the acts_as_authentic
+        # method call. For example, you don't want to start adding in email
+        # validations and what not into a model that has nothing to do with
+        # Authlogic.
         #
-        # That being said, this is your tool for extending Authlogic and "hooking" into the acts_as_authentic call.
+        # That being said, this is your tool for extending Authlogic and
+        # "hooking" into the acts_as_authentic call.
         def add_acts_as_authentic_module(mod, action = :append)
           modules = acts_as_authentic_modules.clone
           case action
@@ -61,7 +57,8 @@ module Authlogic
           self.acts_as_authentic_modules = modules
         end
 
-        # This is the same as add_acts_as_authentic_module, except that it removes the module from the list.
+        # This is the same as add_acts_as_authentic_module, except that it
+        # removes the module from the list.
         def remove_acts_as_authentic_module(mod)
           modules = acts_as_authentic_modules.clone
           modules.delete(mod)
@@ -70,21 +67,23 @@ module Authlogic
 
         private
 
-          def db_setup?
-            begin
-              column_names
-              true
-            rescue StandardError
-              false
-            end
-          end
+        def db_setup?
+          column_names
+          true
+        rescue StandardError
+          false
+        end
 
-          def first_column_to_exist(*columns_to_check)
-            if db_setup?
-              columns_to_check.each { |column_name| return column_name.to_sym if column_names.include?(column_name.to_s) }
+        def first_column_to_exist(*columns_to_check)
+          if db_setup?
+            columns_to_check.each do |column_name|
+              if column_names.include?(column_name.to_s)
+                return column_name.to_sym
+              end
             end
-            columns_to_check.first && columns_to_check.first.to_sym
           end
+          columns_to_check.first&.to_sym
+        end
       end
     end
   end
@@ -98,7 +97,5 @@ end
 ::ActiveRecord::Base.send :include, Authlogic::ActsAsAuthentic::Password
 ::ActiveRecord::Base.send :include, Authlogic::ActsAsAuthentic::PerishableToken
 ::ActiveRecord::Base.send :include, Authlogic::ActsAsAuthentic::PersistenceToken
-::ActiveRecord::Base.send :include, Authlogic::ActsAsAuthentic::RestfulAuthentication
 ::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

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 module Authlogic
   module ActsAsAuthentic
-    # Sometimes models won't have an explicit "login" or "username" field. Instead they want to use the email field.
-    # In this case, authlogic provides validations to make sure the email submited is actually a valid email. Don't worry,
-    # if you do have a login or username field, Authlogic will still validate your email field. One less thing you have to
-    # worry about.
+    # Sometimes models won't have an explicit "login" or "username" field.
+    # Instead they want to use the email field. In this case, authlogic provides
+    # validations to make sure the email submited is actually a valid email.
+    # Don't worry, if you do have a login or username field, Authlogic will
+    # still validate your email field. One less thing you have to worry about.
     module Email
       def self.included(klass)
         klass.class_eval do
           extend Config
-          add_acts_as_authentic_module(Methods)
         end
       end
 
@@ -21,142 +23,7 @@ module Authlogic
         def email_field(value = nil)
           rw_config(:email_field, value, first_column_to_exist(nil, :email, :email_address))
         end
-        alias_method :email_field=, :email_field
-
-        # Toggles validating the email field or not.
-        #
-        # * <tt>Default:</tt> true
-        # * <tt>Accepts:</tt> Boolean
-        def validate_email_field(value = nil)
-          rw_config(:validate_email_field, value, true)
-        end
-        alias_method :validate_email_field=, :validate_email_field
-
-        # A hash of options for the validates_length_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_length_of_email_field_options to merge
-        # options.</b>
-        #
-        # * <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 })
-        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 instead of:
-        #
-        #   self.validates_length_of_email_field_options = validates_length_of_email_field_options.merge(:my_option => my_value)
-        #
-        # You can do this:
-        #
-        #   merge_validates_length_of_email_field_options :my_option => my_value
-        def merge_validates_length_of_email_field_options(options = {})
-          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.
-        #
-        # <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:
-        #
-        # * <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>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 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
-
-        # See merge_validates_length_of_email_field_options. The same thing except for validates_format_of_email_field_options.
-        def merge_validates_format_of_email_field_options(options = {})
-          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.
-        #
-        # <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>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
-            }
-          )
-        end
-        alias_method(
-          :validates_uniqueness_of_email_field_options=,
-          :validates_uniqueness_of_email_field_options
-        )
-
-        # See merge_validates_length_of_email_field_options. The same thing
-        # except for validates_uniqueness_of_email_field_options.
-        def merge_validates_uniqueness_of_email_field_options(options = {})
-          self.validates_uniqueness_of_email_field_options =
-            validates_uniqueness_of_email_field_options.merge(options)
-        end
-      end
-
-      # All methods relating to the email field
-      module Methods
-        def self.included(klass)
-          klass.class_eval do
-            if validate_email_field && email_field
-              validates_length_of email_field, validates_length_of_email_field_options
-              validates_format_of email_field, validates_format_of_email_field_options
-              validates_uniqueness_of email_field, validates_uniqueness_of_email_field_options
-            end
-          end
-        end
+        alias email_field= email_field
       end
     end
   end

data/lib/authlogic/acts_as_authentic/logged_in_status.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 module Authlogic
   module ActsAsAuthentic
-    # Since web applications are stateless there is not sure fire way to tell if a user is logged in or not,
-    # from the database perspective. The best way to do this is to provide a "timeout" based on inactivity.
-    # So if that user is inactive for a certain amount of time we assume they are logged out. That's what this
-    # module is all about.
+    # Since web applications are stateless there is not sure fire way to tell if
+    # a user is logged in or not, from the database perspective. The best way to
+    # do this is to provide a "timeout" based on inactivity. So if that user is
+    # inactive for a certain amount of time we assume they are logged out.
+    # That's what this module is all about.
     module LoggedInStatus
       def self.included(klass)
         klass.class_eval do
@@ -21,13 +24,13 @@ module Authlogic
         def logged_in_timeout(value = nil)
           rw_config(:logged_in_timeout, (!value.nil? && value.to_i) || value, 10.minutes.to_i)
         end
-        alias_method :logged_in_timeout=, :logged_in_timeout
+        alias logged_in_timeout= logged_in_timeout
       end
 
       # All methods for the logged in status feature seat.
       module Methods
         def self.included(klass)
-          return if !klass.column_names.include?("last_request_at")
+          return unless klass.column_names.include?("last_request_at")
 
           klass.class_eval do
             include InstanceMethods
@@ -52,11 +55,15 @@ module Authlogic
           end
         end
 
+        # :nodoc:
         module InstanceMethods
           # Returns true if the last_request_at > logged_in_timeout.
           def logged_in?
             unless respond_to?(:last_request_at)
-              raise "Can not determine the records login state because there is no last_request_at column"
+              raise(
+                "Can not determine the records login state because " \
+                  "there is no last_request_at column"
+              )
             end
             !last_request_at.nil? && last_request_at > logged_in_timeout.seconds.ago
           end
@@ -68,9 +75,9 @@ module Authlogic
 
           private
 
-            def logged_in_timeout
-              self.class.logged_in_timeout
-            end
+          def logged_in_timeout
+            self.class.logged_in_timeout
+          end
         end
       end
     end

data/lib/authlogic/acts_as_authentic/login.rb

@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
+require "authlogic/acts_as_authentic/queries/case_sensitivity"
+require "authlogic/acts_as_authentic/queries/find_with_case"
+
 module Authlogic
   module ActsAsAuthentic
     # Handles everything related to the login field.
@@ -5,7 +10,6 @@ module Authlogic
       def self.included(klass)
         klass.class_eval do
           extend Config
-          add_acts_as_authentic_module(Methods)
         end
       end
 
@@ -18,128 +22,7 @@ module Authlogic
         def login_field(value = nil)
           rw_config(:login_field, value, first_column_to_exist(nil, :login, :username))
         end
-        alias_method :login_field=, :login_field
-
-        # Whether or not to validate the login field
-        #
-        # * <tt>Default:</tt> true
-        # * <tt>Accepts:</tt> Boolean
-        def validate_login_field(value = nil)
-          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 merge options into
-        # it. Checkout the convenience function
-        # merge_validates_length_of_login_field_options to merge options.</b>
-        #
-        # * <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 })
-        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 instead of:
-        #
-        #   self.validates_length_of_login_field_options =
-        #     validates_length_of_login_field_options.merge(:my_option => my_value)
-        #
-        # You can do this:
-        #
-        #   merge_validates_length_of_login_field_options :my_option => my_value
-        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 => 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 => proc do
-                I18n.t(
-                  'error_messages.login_invalid',
-                  :default => "should use only letters, numbers, spaces, and .-_@+ please."
-                )
-              end
-            }
-          )
-        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 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>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
-            }
-          )
-        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
+        alias login_field= login_field
 
         # This method allows you to find a record with the given login. If you
         # notice, with Active Record you have the UniquenessValidator class.
@@ -160,53 +43,19 @@ module Authlogic
         # The above also applies for using email as your login, except that you
         # need to set the :case_sensitive in
         # validates_uniqueness_of_email_field_options to false.
+        #
+        # @api public
         def find_by_smart_case_login_field(login)
-          if login_field
-            find_with_case(login_field, login, validates_uniqueness_of_login_field_options[:case_sensitive] != false)
-          else
-            find_with_case(email_field, login, validates_uniqueness_of_email_field_options[:case_sensitive] != false)
-          end
+          field = login_field || email_field
+          sensitive = Queries::CaseSensitivity.new(self, field).sensitive?
+          find_with_case(field, login, sensitive)
         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 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
-              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
-          end
-      end
-
-      # All methods relating to the login field
-      module Methods
-        # Adds in various validations, modules, etc.
-        def self.included(klass)
-          klass.class_eval do
-            if validate_login_field && login_field
-              validates_length_of login_field, validates_length_of_login_field_options
-              validates_format_of login_field, validates_format_of_login_field_options
-              validates_uniqueness_of login_field, validates_uniqueness_of_login_field_options
-            end
-          end
+        # @api private
+        def find_with_case(field, value, sensitive)
+          Queries::FindWithCase.new(self, field, value, sensitive).execute
         end
       end
     end

data/lib/authlogic/acts_as_authentic/magic_columns.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 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 "Magic Columns" in
+    # `Session::Base` 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
@@ -17,15 +20,15 @@ module Authlogic
           klass.class_eval do
             if column_names.include?("login_count")
               validates_numericality_of :login_count,
-                :only_integer => true,
-                :greater_than_or_equal_to => 0,
-                :allow_nil => true
+                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
+                only_integer: true,
+                greater_than_or_equal_to: 0,
+                allow_nil: true
             end
           end
         end