activerecord 6.0.6 → 6.1.0

data/lib/active_record/scoping/named.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/array"
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/kernel/singleton_class"
-
 module ActiveRecord
   # = Active Record \Named \Scopes
   module Scoping
@@ -27,14 +23,6 @@ module ActiveRecord
           scope = current_scope
 
           if scope
-            if scope._deprecated_scope_source
-              ActiveSupport::Deprecation.warn(<<~MSG.squish)
-                Class level methods will no longer inherit scoping from `#{scope._deprecated_scope_source}`
-                in Rails 6.1. To continue using the scoped relation, pass it into the block directly.
-                To instead access the full set of models, as Rails 6.1 will, use `#{name}.default_scoped`.
-              MSG
-            end
-
             if self == scope.klass
               scope.clone
             else
@@ -84,10 +72,6 @@ module ActiveRecord
         # <tt>Shirt.dry_clean_only</tt>. <tt>Shirt.red</tt>, in effect,
         # represents the query <tt>Shirt.where(color: 'red')</tt>.
         #
-        # You should always pass a callable object to the scopes defined
-        # with #scope. This ensures that the scope is re-evaluated each
-        # time it is called.
-        #
         # Note that this is simply 'syntactic sugar' for defining an actual
         # class method:
         #
@@ -189,7 +173,7 @@ module ActiveRecord
 
           if body.respond_to?(:to_proc)
             singleton_class.define_method(name) do |*args|
-              scope = all._exec_scope(name, *args, &body)
+              scope = all._exec_scope(*args, &body)
               scope = scope.extending(extension) if extension
               scope
             end

data/lib/active_record/secure_token.rb

@@ -2,6 +2,10 @@
 
 module ActiveRecord
   module SecureToken
+    class MinimumLengthError < StandardError; end
+
+    MINIMUM_TOKEN_LENGTH = 24
+
     extend ActiveSupport::Concern
 
     module ClassMethods
@@ -10,30 +14,34 @@ module ActiveRecord
       #   # Schema: User(token:string, auth_token:string)
       #   class User < ActiveRecord::Base
       #     has_secure_token
-      #     has_secure_token :auth_token
+      #     has_secure_token :auth_token, length: 36
       #   end
       #
       #   user = User.new
       #   user.save
       #   user.token # => "pX27zsMN2ViQKta1bGfLmVJE"
-      #   user.auth_token # => "77TMHrHJFvFDwodq8w7Ev2m7"
+      #   user.auth_token # => "tU9bLuZseefXQ4yQxQo8wjtBvsAfPc78os6R"
       #   user.regenerate_token # => true
       #   user.regenerate_auth_token # => true
       #
-      # <tt>SecureRandom::base58</tt> is used to generate the 24-character unique token, so collisions are highly unlikely.
+      # <tt>SecureRandom::base58</tt> is used to generate at minimum a 24-character unique token, so collisions are highly unlikely.
       #
       # Note that it's still possible to generate a race condition in the database in the same way that
       # {validates_uniqueness_of}[rdoc-ref:Validations::ClassMethods#validates_uniqueness_of] can.
       # You're encouraged to add a unique index in the database to deal with this even more unlikely scenario.
-      def has_secure_token(attribute = :token)
+      def has_secure_token(attribute = :token, length: MINIMUM_TOKEN_LENGTH)
+        if length < MINIMUM_TOKEN_LENGTH
+          raise MinimumLengthError, "Token requires a minimum length of #{MINIMUM_TOKEN_LENGTH} characters."
+        end
+
         # Load securerandom only when has_secure_token is used.
         require "active_support/core_ext/securerandom"
-        define_method("regenerate_#{attribute}") { update! attribute => self.class.generate_unique_secure_token }
-        before_create { send("#{attribute}=", self.class.generate_unique_secure_token) unless send("#{attribute}?") }
+        define_method("regenerate_#{attribute}") { update! attribute => self.class.generate_unique_secure_token(length: length) }
+        before_create { send("#{attribute}=", self.class.generate_unique_secure_token(length: length)) unless send("#{attribute}?") }
       end
 
-      def generate_unique_secure_token
-        SecureRandom.base58(24)
+      def generate_unique_secure_token(length: MINIMUM_TOKEN_LENGTH)
+        SecureRandom.base58(length)
       end
     end
   end

data/lib/active_record/serialization.rb

@@ -11,10 +11,12 @@ module ActiveRecord #:nodoc:
     end
 
     def serializable_hash(options = nil)
-      options = options.try(:dup) || {}
+      if self.class._has_attribute?(self.class.inheritance_column)
+        options = options ? options.dup : {}
 
-      options[:except] = Array(options[:except]).map(&:to_s)
-      options[:except] |= Array(self.class.inheritance_column)
+        options[:except] = Array(options[:except]).map(&:to_s)
+        options[:except] |= Array(self.class.inheritance_column)
+      end
 
       super(options)
     end

data/lib/active_record/signed_id.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  # = Active Record Signed Id
+  module SignedId
+    extend ActiveSupport::Concern
+
+    included do
+      ##
+      # :singleton-method:
+      # Set the secret used for the signed id verifier instance when using Active Record outside of Rails.
+      # Within Rails, this is automatically set using the Rails application key generator.
+      mattr_accessor :signed_id_verifier_secret, instance_writer: false
+    end
+
+    module ClassMethods
+      # Lets you find a record based on a signed id that's safe to put into the world without risk of tampering.
+      # This is particularly useful for things like password reset or email verification, where you want
+      # the bearer of the signed id to be able to interact with the underlying record, but usually only within
+      # a certain time period.
+      #
+      # You set the time period that the signed id is valid for during generation, using the instance method
+      # +signed_id(expires_in: 15.minutes)+. If the time has elapsed before a signed find is attempted,
+      # the signed id will no longer be valid, and nil is returned.
+      #
+      # It's possible to further restrict the use of a signed id with a purpose. This helps when you have a
+      # general base model, like a User, which might have signed ids for several things, like password reset
+      # or email verification. The purpose that was set during generation must match the purpose set when
+      # finding. If there's a mismatch, nil is again returned.
+      #
+      # ==== Examples
+      #
+      #   signed_id = User.first.signed_id expires_in: 15.minutes, purpose: :password_reset
+      #
+      #   User.find_signed signed_id # => nil, since the purpose does not match
+      #
+      #   travel 16.minutes
+      #   User.find_signed signed_id, purpose: :password_reset # => nil, since the signed id has expired
+      #
+      #   travel_back
+      #   User.find_signed signed_id, purpose: :password_reset # => User.first
+      def find_signed(signed_id, purpose: nil)
+        raise UnknownPrimaryKey.new(self) if primary_key.nil?
+
+        if id = signed_id_verifier.verified(signed_id, purpose: combine_signed_id_purposes(purpose))
+          find_by primary_key => id
+        end
+      end
+
+      # Works like +find_signed+, but will raise an +ActiveSupport::MessageVerifier::InvalidSignature+
+      # exception if the +signed_id+ has either expired, has a purpose mismatch, is for another record,
+      # or has been tampered with. It will also raise an +ActiveRecord::RecordNotFound+ exception if
+      # the valid signed id can't find a record.
+      #
+      # === Examples
+      #
+      #   User.find_signed! "bad data" # => ActiveSupport::MessageVerifier::InvalidSignature
+      #
+      #   signed_id = User.first.signed_id
+      #   User.first.destroy
+      #   User.find_signed! signed_id # => ActiveRecord::RecordNotFound
+      def find_signed!(signed_id, purpose: nil)
+        if id = signed_id_verifier.verify(signed_id, purpose: combine_signed_id_purposes(purpose))
+          find(id)
+        end
+      end
+
+      # The verifier instance that all signed ids are generated and verified from. By default, it'll be initialized
+      # with the class-level +signed_id_verifier_secret+, which within Rails comes from the
+      # Rails.application.key_generator. By default, it's SHA256 for the digest and JSON for the serialization.
+      def signed_id_verifier
+        @signed_id_verifier ||= begin
+          secret = signed_id_verifier_secret
+          secret = secret.call if secret.respond_to?(:call)
+
+          if secret.nil?
+            raise ArgumentError, "You must set ActiveRecord::Base.signed_id_verifier_secret to use signed ids"
+          else
+            ActiveSupport::MessageVerifier.new secret, digest: "SHA256", serializer: JSON
+          end
+        end
+      end
+
+      # Allows you to pass in a custom verifier used for the signed ids. This also allows you to use different
+      # verifiers for different classes. This is also helpful if you need to rotate keys, as you can prepare
+      # your custom verifier for that in advance. See +ActiveSupport::MessageVerifier+ for details.
+      def signed_id_verifier=(verifier)
+        @signed_id_verifier = verifier
+      end
+
+      # :nodoc:
+      def combine_signed_id_purposes(purpose)
+        [ base_class.name.underscore, purpose.to_s ].compact_blank.join("/")
+      end
+    end
+
+
+    # Returns a signed id that's generated using a preconfigured +ActiveSupport::MessageVerifier+ instance.
+    # This signed id is tamper proof, so it's safe to send in an email or otherwise share with the outside world.
+    # It can further more be set to expire (the default is not to expire), and scoped down with a specific purpose.
+    # If the expiration date has been exceeded before +find_signed+ is called, the id won't find the designated
+    # record. If a purpose is set, this too must match.
+    #
+    # If you accidentally let a signed id out in the wild that you wish to retract sooner than its expiration date
+    # (or maybe you forgot to set an expiration date while meaning to!), you can use the purpose to essentially
+    # version the signed_id, like so:
+    #
+    #   user.signed_id purpose: :v2
+    #
+    # And you then change your +find_signed+ calls to require this new purpose. Any old signed ids that were not
+    # created with the purpose will no longer find the record.
+    def signed_id(expires_in: nil, purpose: nil)
+      self.class.signed_id_verifier.generate id, expires_in: expires_in, purpose: self.class.combine_signed_id_purposes(purpose)
+    end
+  end
+end

data/lib/active_record/statement_cache.rb

@@ -50,13 +50,20 @@ module ActiveRecord
 
       def sql_for(binds, connection)
         val = @values.dup
-        casted_binds = binds.map(&:value_for_database)
-        @indexes.each { |i| val[i] = connection.quote(casted_binds.shift) }
+        @indexes.each do |i|
+          value = binds.shift
+          if ActiveModel::Attribute === value
+            value = value.value_for_database
+          end
+          val[i] = connection.quote(value)
+        end
         val.join
       end
     end
 
     class PartialQueryCollector
+      attr_accessor :preparable
+
       def initialize
         @parts = []
         @binds = []
@@ -73,6 +80,15 @@ module ActiveRecord
         self
       end
 
+      def add_binds(binds)
+        @binds.concat binds
+        binds.size.times do |i|
+          @parts << ", " unless i == 0
+          @parts << Substitute.new
+        end
+        self
+      end
+
       def value
         [@parts, @binds]
       end
@@ -100,7 +116,7 @@ module ActiveRecord
         @bound_attributes = bound_attributes
 
         bound_attributes.each_with_index do |attr, i|
-          if Substitute === attr.value
+          if ActiveModel::Attribute === attr && Substitute === attr.value
             @indexes << i
           end
         end
@@ -133,7 +149,7 @@ module ActiveRecord
 
       klass.find_by_sql(sql, bind_values, preparable: true, &block)
     rescue ::RangeError
-      nil
+      []
     end
 
     def self.unsupported_value?(value)

data/lib/active_record/store.rb

@@ -23,7 +23,7 @@ module ActiveRecord
   # You can set custom coder to encode/decode your serialized attributes to/from different formats.
   # JSON, YAML, Marshal are supported out of the box. Generally it can be any wrapper that provides +load+ and +dump+.
   #
-  # NOTE: If you are using structured database data types (eg. PostgreSQL +hstore+/+json+, or MySQL 5.7+
+  # NOTE: If you are using structured database data types (e.g. PostgreSQL +hstore+/+json+, or MySQL 5.7+
   # +json+) there is no need for the serialization provided by {.store}[rdoc-ref:rdoc-ref:ClassMethods#store].
   # Simply use {.store_accessor}[rdoc-ref:ClassMethods#store_accessor] instead to generate
   # the accessor methods. Be aware that these columns use a string keyed hash and do not allow access
@@ -251,7 +251,7 @@ module ActiveRecord
           attribute = object.send(store_attribute)
           unless attribute.is_a?(ActiveSupport::HashWithIndifferentAccess)
             attribute = IndifferentCoder.as_indifferent_hash(attribute)
-            object.send :"#{store_attribute}=", attribute
+            object.public_send :"#{store_attribute}=", attribute
           end
           attribute
         end

data/lib/active_record/suppressor.rb

@@ -40,11 +40,11 @@ module ActiveRecord
       end
     end
 
-    def save(*, **) # :nodoc:
+    def save(**) # :nodoc:
       SuppressorRegistry.suppressed[self.class.name] ? true : super
     end
 
-    def save!(*, **) # :nodoc:
+    def save!(**) # :nodoc:
       SuppressorRegistry.suppressed[self.class.name] ? true : super
     end
   end

data/lib/active_record/table_metadata.rb

@@ -2,89 +2,77 @@
 
 module ActiveRecord
   class TableMetadata # :nodoc:
-    delegate :foreign_type, :foreign_key, :join_primary_key, :join_foreign_key, to: :association, prefix: true
+    delegate :join_primary_key, :join_foreign_key, :join_foreign_type, to: :reflection
 
-    def initialize(klass, arel_table, association = nil, types = klass)
+    def initialize(klass, arel_table, reflection = nil)
       @klass = klass
-      @types = types
       @arel_table = arel_table
-      @association = association
+      @reflection = reflection
     end
 
-    def resolve_column_aliases(hash)
-      new_hash = hash.dup
-      hash.each_key do |key|
-        if key.is_a?(Symbol) && new_key = klass.attribute_aliases[key.to_s]
-          new_hash[new_key] = new_hash.delete(key)
-        end
-      end
-      new_hash
-    end
-
-    def arel_attribute(column_name)
-      if klass
-        klass.arel_attribute(column_name, arel_table)
-      else
-        arel_table[column_name]
-      end
+    def primary_key
+      klass&.primary_key
     end
 
     def type(column_name)
-      types.type_for_attribute(column_name)
+      arel_table.type_for_attribute(column_name)
     end
 
     def has_column?(column_name)
-      klass && klass.columns_hash.key?(column_name.to_s)
+      klass&.columns_hash.key?(column_name)
     end
 
-    def associated_with?(association_name)
-      klass && klass._reflect_on_association(association_name)
+    def associated_with?(table_name)
+      klass&._reflect_on_association(table_name) || klass&._reflect_on_association(table_name.singularize)
     end
 
     def associated_table(table_name)
-      association = klass._reflect_on_association(table_name) || klass._reflect_on_association(table_name.to_s.singularize)
-
-      if !association && table_name == arel_table.name
-        self
-      elsif association && !association.polymorphic?
-        association_klass = association.klass
-        arel_table = association_klass.arel_table.alias(table_name)
-        TableMetadata.new(association_klass, arel_table, association)
+      reflection = klass._reflect_on_association(table_name) || klass._reflect_on_association(table_name.singularize)
+
+      if !reflection && table_name == arel_table.name
+        return self
+      end
+
+      reflection ||= yield table_name if block_given?
+
+      if reflection && !reflection.polymorphic?
+        association_klass = reflection.klass
+        arel_table = association_klass.arel_table
+        arel_table = arel_table.alias(table_name) if arel_table.name != table_name
+        TableMetadata.new(association_klass, arel_table, reflection)
       else
         type_caster = TypeCaster::Connection.new(klass, table_name)
         arel_table = Arel::Table.new(table_name, type_caster: type_caster)
-        TableMetadata.new(nil, arel_table, association, type_caster)
+        TableMetadata.new(nil, arel_table, reflection)
       end
     end
 
-    def associated_predicate_builder(table_name)
-      associated_table(table_name).predicate_builder
-    end
-
     def polymorphic_association?
-      association && association.polymorphic?
+      reflection&.polymorphic?
     end
 
-    def aggregated_with?(aggregation_name)
-      klass && reflect_on_aggregation(aggregation_name)
+    def through_association?
+      reflection&.through_reflection?
     end
 
     def reflect_on_aggregation(aggregation_name)
-      klass.reflect_on_aggregation(aggregation_name)
+      klass&.reflect_on_aggregation(aggregation_name)
     end
+    alias :aggregated_with? :reflect_on_aggregation
 
-    protected
-      def predicate_builder
-        if klass
-          predicate_builder = klass.predicate_builder.dup
-          predicate_builder.instance_variable_set(:@table, self)
-          predicate_builder
-        else
-          PredicateBuilder.new(self)
-        end
+    def predicate_builder
+      if klass
+        predicate_builder = klass.predicate_builder.dup
+        predicate_builder.instance_variable_set(:@table, self)
+        predicate_builder
+      else
+        PredicateBuilder.new(self)
       end
+    end
+
+    attr_reader :arel_table
 
     private
-      attr_reader :klass, :types, :arel_table, :association
+      attr_reader :klass, :reflection
   end
 end