activerecord 6.0.4.8 → 6.1.0.rc1

data/lib/active_record/result.rb

@@ -65,16 +65,10 @@ module ActiveRecord
       end
     end
 
-    def to_hash
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-        `ActiveRecord::Result#to_hash` has been renamed to `to_a`.
-        `to_hash` is deprecated and will be removed in Rails 6.1.
-      MSG
-      to_a
-    end
-
     alias :map! :map
     alias :collect! :map
+    deprecate "map!": :map
+    deprecate "collect!": :map
 
     # Returns true if there are no records, otherwise false.
     def empty?
@@ -92,31 +86,30 @@ module ActiveRecord
       hash_rows[idx]
     end
 
-    # Returns the first record from the rows collection.
-    # If the rows collection is empty, returns +nil+.
-    def first
-      return nil if @rows.empty?
-      Hash[@columns.zip(@rows.first)]
-    end
-
     # Returns the last record from the rows collection.
-    # If the rows collection is empty, returns +nil+.
-    def last
-      return nil if @rows.empty?
-      Hash[@columns.zip(@rows.last)]
+    def last(n = nil)
+      n ? hash_rows.last(n) : hash_rows.last
     end
 
     def cast_values(type_overrides = {}) # :nodoc:
       if columns.one?
         # Separated to avoid allocating an array per row
 
-        type = column_type(columns.first, type_overrides)
+        type = if type_overrides.is_a?(Array)
+          type_overrides.first
+        else
+          column_type(columns.first, type_overrides)
+        end
 
         rows.map do |(value)|
           type.deserialize(value)
         end
       else
-        types = columns.map { |name| column_type(name, type_overrides) }
+        types = if type_overrides.is_a?(Array)
+          type_overrides
+        else
+          columns.map { |name| column_type(name, type_overrides) }
+        end
 
         rows.map do |values|
           Array.new(values.size) { |i| types[i].deserialize(values[i]) }
@@ -145,21 +138,36 @@ module ActiveRecord
             # used as keys in ActiveRecord::Base's @attributes hash
             columns = @columns.map(&:-@)
             length  = columns.length
+            template = nil
 
             @rows.map { |row|
-              # In the past we used Hash[columns.zip(row)]
-              #  though elegant, the verbose way is much more efficient
-              #  both time and memory wise cause it avoids a big array allocation
-              #  this method is called a lot and needs to be micro optimised
-              hash = {}
-
-              index = 0
-              while index < length
-                hash[columns[index]] = row[index]
-                index += 1
+              if template
+                # We use transform_values to build subsequent rows from the
+                # hash of the first row. This is faster because we avoid any
+                # reallocs and in Ruby 2.7+ avoid hashing entirely.
+                index = -1
+                template.transform_values do
+                  row[index += 1]
+                end
+              else
+                # In the past we used Hash[columns.zip(row)]
+                #  though elegant, the verbose way is much more efficient
+                #  both time and memory wise cause it avoids a big array allocation
+                #  this method is called a lot and needs to be micro optimised
+                hash = {}
+
+                index = 0
+                while index < length
+                  hash[columns[index]] = row[index]
+                  index += 1
+                end
+
+                # It's possible to select the same column twice, in which case
+                # we can't use a template
+                template = hash if hash.length == length
+
+                hash
               end
-
-              hash
             }
           end
       end

data/lib/active_record/runtime_registry.rb

@@ -14,9 +14,9 @@ module ActiveRecord
   class RuntimeRegistry # :nodoc:
     extend ActiveSupport::PerThreadRegistry
 
-    attr_accessor :connection_handler, :sql_runtime
+    attr_accessor :sql_runtime
 
-    [:connection_handler, :sql_runtime].each do |val|
+    [:sql_runtime].each do |val|
       class_eval %{ def self.#{val}; instance.#{val}; end }, __FILE__, __LINE__
       class_eval %{ def self.#{val}=(x); instance.#{val}=x; end }, __FILE__, __LINE__
     end

data/lib/active_record/sanitization.rb

@@ -67,7 +67,7 @@ module ActiveRecord
           )
 
           # Ensure we aren't dealing with a subclass of String that might
-          # override methods we use (eg. Arel::Nodes::SqlLiteral).
+          # override methods we use (e.g. Arel::Nodes::SqlLiteral).
           if condition.first.kind_of?(String) && !condition.first.instance_of?(String)
             condition = [String.new(condition.first), *condition[1..-1]]
           end
@@ -141,19 +141,7 @@ module ActiveRecord
           (unexpected ||= []) << arg
         end
 
-        return unless unexpected
-
-        if allow_unsafe_raw_sql == :deprecated
-          ActiveSupport::Deprecation.warn(
-            "Dangerous query method (method whose arguments are used as raw " \
-            "SQL) called with non-attribute argument(s): " \
-            "#{unexpected.map(&:inspect).join(", ")}. Non-attribute " \
-            "arguments will be disallowed in Rails 6.1. This method should " \
-            "not be called with user-provided values, such as request " \
-            "parameters or model attributes. Known-safe values can be passed " \
-            "by wrapping them in Arel.sql()."
-          )
-        else
+        if unexpected
           raise(ActiveRecord::UnknownAttributeReference,
             "Query method called with non-attribute argument(s): " +
             unexpected.map(&:inspect).join(", ")
@@ -193,13 +181,14 @@ module ActiveRecord
 
         def quote_bound_value(value, c = connection)
           if value.respond_to?(:map) && !value.acts_like?(:string)
-            quoted = value.map { |v| c.quote(v) }
-            if quoted.empty?
+            values = value.map { |v| v.respond_to?(:id_for_database) ? v.id_for_database : v }
+            if values.empty?
               c.quote(nil)
             else
-              quoted.join(",")
+              values.map! { |v| c.quote(v) }.join(",")
             end
           else
+            value = value.id_for_database if value.respond_to?(:id_for_database)
             c.quote(value)
           end
         end

data/lib/active_record/schema_dumper.rb

@@ -23,6 +23,12 @@ module ActiveRecord
     # should not be dumped to db/schema.rb.
     cattr_accessor :fk_ignore_pattern, default: /^fk_rails_[0-9a-f]{10}$/
 
+    ##
+    # :singleton-method:
+    # Specify a custom regular expression matching check constraints which name
+    # should not be dumped to db/schema.rb.
+    cattr_accessor :chk_ignore_pattern, default: /^chk_rails_[0-9a-f]{10}$/
+
     class << self
       def dump(connection = ActiveRecord::Base.connection, stream = STDOUT, config = ActiveRecord::Base)
         connection.create_schema_dumper(generate_options(config)).dump(stream)
@@ -72,8 +78,8 @@ module ActiveRecord
 # of editing this file, please use the migrations feature of Active Record to
 # incrementally modify your database, and then regenerate this schema definition.
 #
-# This file is the source Rails uses to define your schema when running `rails
-# db:schema:load`. When creating a new database, `rails db:schema:load` tends to
+# This file is the source Rails uses to define your schema when running `bin/rails
+# db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
 # be faster and is potentially less error prone than running all of your
 # migrations from scratch. Old migrations may fail to apply correctly if those
 # migrations use external dependencies or application code.
@@ -125,7 +131,10 @@ HEADER
             tbl.print ", primary_key: #{pk.inspect}" unless pk == "id"
             pkcol = columns.detect { |c| c.name == pk }
             pkcolspec = column_spec_for_primary_key(pkcol)
-            if pkcolspec.present?
+            unless pkcolspec.empty?
+              if pkcolspec != pkcolspec.slice(:id, :default)
+                pkcolspec = { id: { type: pkcolspec.delete(:id), **pkcolspec }.compact }
+              end
               tbl.print ", #{format_colspec(pkcolspec)}"
             end
           when Array
@@ -156,6 +165,7 @@ HEADER
           end
 
           indexes_in_create(table, tbl)
+          check_constraints_in_create(table, tbl) if @connection.supports_check_constraints?
 
           tbl.puts "  end"
           tbl.puts
@@ -209,6 +219,24 @@ HEADER
         index_parts
       end
 
+      def check_constraints_in_create(table, stream)
+        if (check_constraints = @connection.check_constraints(table)).any?
+          add_check_constraint_statements = check_constraints.map do |check_constraint|
+            parts = [
+              "t.check_constraint #{check_constraint.expression.inspect}"
+            ]
+
+            if check_constraint.export_name_on_schema_dump?
+              parts << "name: #{check_constraint.name.inspect}"
+            end
+
+            "    #{parts.join(', ')}"
+          end
+
+          stream.puts add_check_constraint_statements.sort.join("\n")
+        end
+      end
+
       def foreign_keys(table, stream)
         if (foreign_keys = @connection.foreign_keys(table)).any?
           add_foreign_key_statements = foreign_keys.map do |foreign_key|
@@ -240,7 +268,9 @@ HEADER
       end
 
       def format_colspec(colspec)
-        colspec.map { |key, value| "#{key}: #{value}" }.join(", ")
+        colspec.map do |key, value|
+          "#{key}: #{ value.is_a?(Hash) ? "{ #{format_colspec(value)} }" : value }"
+        end.join(", ")
       end
 
       def format_options(options)

data/lib/active_record/schema_migration.rb

@@ -22,10 +22,6 @@ module ActiveRecord
         "#{table_name_prefix}#{schema_migrations_table_name}#{table_name_suffix}"
       end
 
-      def table_exists?
-        connection.table_exists?(table_name)
-      end
-
       def create_table
         unless table_exists?
           version_options = connection.internal_string_options_for_primary_key

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