activerecord 6.1.0.rc1 → 6.1.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66ac86600eb6f03cff86765392e7ec1baf5741aca1050133653dab7d9552ede3
-  data.tar.gz: ab475bbab2246deea73d3d699374c6f309fdddc97f467d783695af1e737cb352
+  metadata.gz: b093236482caac43173dfffd7096282d55d6fc0099ed9f6e684b84efabfbb466
+  data.tar.gz: ef623a179fbabb3fd9aa544baf87da3bf342cca09dd6a2bf9bd3f4d2435410a8
 SHA512:
-  metadata.gz: 51480027525839e315d70abb310a433cfa48c9fb25084ba13ce4d18d205e0d3eb4ae79fe259716a15c055e7083d381e590ddc4e6829662c21276cacf70845834
-  data.tar.gz: ec51c2bc1172ec830f700aea91674fed170a9d362c7a8be600328055db0132d79b38049d8ee9ad03729b962c7667982519b3fb0bfa8569cac7c3686c8f73ebd3
+  metadata.gz: 3ba3873e17ac4ad32e19d81a7669b24024195986c8cbbf9eb54ae9ecf798d9f82369594051712609458bf84f4bb58228c0dfcef9ce21cb8926dd07dd898efaba
+  data.tar.gz: 8fadd55a99b48ba91ec273fc76d24d3257d67c89999fde3851547b29711244b649edccbeb9c4ff9ba326348a61be4da361fd49f35dcd55109c19ada385f47de6

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+## Rails 6.1.0.rc2 (December 01, 2020) ##
+
+*   Fix odd behavior of inverse_of with multiple belongs_to to same class.
+
+    Fixes #35204.
+
+    *Tomoyuki Kai*
+
+*   Build predicate conditions with objects that delegate `#id` and primary key:
+
+    ```ruby
+    class AdminAuthor
+      delegate_missing_to :@author
+
+      def initialize(author)
+        @author = author
+      end
+    end
+
+    Post.where(author: AdminAuthor.new(author))
+    ```
+
+    *Sean Doyle*
+
+
 ## Rails 6.1.0.rc1 (November 02, 2020) ##
 
 *   Add `connected_to_many` API.
@@ -108,7 +133,7 @@
 
 *   Named scope chain does no longer leak scope to class level querying methods.
 
-        class class User < ActiveRecord::Base
+        class User < ActiveRecord::Base
           scope :david, -> { User.where(name: "David") }
         end
 
@@ -665,14 +690,14 @@
 
     *Ryuta Kamizono*
 
-*   Inspect time attributes with subsec.
+*   Inspect time attributes with subsec and time zone offset.
 
     ```ruby
     p Knot.create
-    => #<Knot id: 1, created_at: "2016-05-05 01:29:47.116928000">
+    => #<Knot id: 1, created_at: "2016-05-05 01:29:47.116928000 +0000">
     ```
 
-    *akinomaeni*
+    *akinomaeni*, *Jonathan Hefner*
 
 *   Deprecate passing a column to `type_cast`.
 

data/lib/active_record/associations/association.rb

@@ -131,6 +131,11 @@ module ActiveRecord
       end
 
       def inversed_from(record)
+        self.target = record
+        @inversed = !!record
+      end
+
+      def inversed_from_queries(record)
         if inversable?(record)
           self.target = record
           @inversed = true
@@ -138,7 +143,6 @@ module ActiveRecord
           @inversed = false
         end
       end
-      alias :inversed_from_queries :inversed_from
 
       # Returns the class of the target. belongs_to polymorphic overrides this to look at the
       # polymorphic_type field on the owner.
@@ -337,7 +341,8 @@ module ActiveRecord
 
         def matches_foreign_key?(record)
           if foreign_key_for?(record)
-            record.read_attribute(reflection.foreign_key) == owner.id
+            record.read_attribute(reflection.foreign_key) == owner.id ||
+              (foreign_key_for?(owner) && owner.read_attribute(reflection.foreign_key) == record.id)
           else
             owner.read_attribute(reflection.foreign_key) == record.id
           end

data/lib/active_record/attribute_methods/serialization.rb

@@ -41,6 +41,12 @@ module ActiveRecord
         # * +class_name_or_coder+ - Optional, a coder object, which responds to +.load+ and +.dump+
         #   or a class name that the object type should be equal to.
         #
+        # ==== Options
+        #
+        # +default+ The default value to use when no value is provided. If this option
+        # is not passed, the previous default value (if any) will be used.
+        # Otherwise, the default will be +nil+.
+        #
         # ==== Example
         #
         #   # Serialize a preferences attribute.
@@ -57,7 +63,7 @@ module ActiveRecord
         #   class User < ActiveRecord::Base
         #     serialize :preferences, Hash
         #   end
-        def serialize(attr_name, class_name_or_coder = Object)
+        def serialize(attr_name, class_name_or_coder = Object, **options)
           # When ::JSON is used, force it to go through the Active Support JSON encoder
           # to ensure special objects (e.g. Active Record models) are dumped correctly
           # using the #as_json hook.
@@ -69,7 +75,7 @@ module ActiveRecord
             Coders::YAMLColumn.new(attr_name, class_name_or_coder)
           end
 
-          decorate_attribute_type(attr_name.to_s) do |cast_type|
+          decorate_attribute_type(attr_name.to_s, **options) do |cast_type|
             if type_incompatible_with_serialize?(cast_type, class_name_or_coder)
               raise ColumnNotSerializableError.new(attr_name, cast_type)
             end

data/lib/active_record/attributes.rb

@@ -12,6 +12,9 @@ module ActiveRecord
     end
 
     module ClassMethods
+      ##
+      # :call-seq: attribute(name, cast_type = nil, **options)
+      #
       # Defines an attribute with a type on this model. It will override the
       # type of existing attributes if needed. This allows control over how
       # values are converted to and from SQL when assigned to a model. It also
@@ -273,6 +276,8 @@ module ActiveRecord
         def decorate_attribute_type(attr_name, **default)
           type, options = attributes_to_define_after_schema_loads[attr_name]
 
+          default.with_defaults!(default: options[:default]) if options&.key?(:default)
+
           attribute(attr_name, **default) do |cast_type|
             if type && !type.is_a?(Proc)
               cast_type = _lookup_cast_type(attr_name, type, options)

data/lib/active_record/callbacks.rb

@@ -301,8 +301,128 @@ module ActiveRecord
       :before_destroy, :around_destroy, :after_destroy, :after_commit, :after_rollback
     ]
 
-    module ClassMethods # :nodoc:
+    module ClassMethods
       include ActiveModel::Callbacks
+
+      ##
+      # :method: after_initialize
+      #
+      # :call-seq: after_initialize(*args, &block)
+      #
+      # Registers a callback to be called after a record is instantiated. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: after_find
+      #
+      # :call-seq: after_find(*args, &block)
+      #
+      # Registers a callback to be called after a record is instantiated
+      # via a finder. See ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: after_touch
+      #
+      # :call-seq: after_touch(*args, &block)
+      #
+      # Registers a callback to be called after a record is touched. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: before_save
+      #
+      # :call-seq: before_save(*args, &block)
+      #
+      # Registers a callback to be called before a record is saved. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: around_save
+      #
+      # :call-seq: around_save(*args, &block)
+      #
+      # Registers a callback to be called around the save of a record. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: after_save
+      #
+      # :call-seq: after_save(*args, &block)
+      #
+      # Registers a callback to be called after a record is saved. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: before_create
+      #
+      # :call-seq: before_create(*args, &block)
+      #
+      # Registers a callback to be called before a record is created. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: around_create
+      #
+      # :call-seq: around_create(*args, &block)
+      #
+      # Registers a callback to be called around the creation of a record. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: after_create
+      #
+      # :call-seq: after_create(*args, &block)
+      #
+      # Registers a callback to be called after a record is created. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: before_update
+      #
+      # :call-seq: before_update(*args, &block)
+      #
+      # Registers a callback to be called before a record is updated. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: around_update
+      #
+      # :call-seq: around_update(*args, &block)
+      #
+      # Registers a callback to be called around the update of a record. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: after_update
+      #
+      # :call-seq: after_update(*args, &block)
+      #
+      # Registers a callback to be called after a record is updated. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: before_destroy
+      #
+      # :call-seq: before_destroy(*args, &block)
+      #
+      # Registers a callback to be called before a record is destroyed. See
+      # ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: around_destroy
+      #
+      # :call-seq: around_destroy(*args, &block)
+      #
+      # Registers a callback to be called around the destruction of a record.
+      # See ActiveRecord::Callbacks for more information.
+
+      ##
+      # :method: after_destroy
+      #
+      # :call-seq: after_destroy(*args, &block)
+      #
+      # Registers a callback to be called after a record is destroyed. See
+      # ActiveRecord::Callbacks for more information.
     end
 
     included do

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -23,6 +23,10 @@ module ActiveRecord
       include ConnectionAdapters::AbstractPool
 
       attr_accessor :schema_cache
+
+      def owner_name
+        nil
+      end
     end
 
     # Connection pool base class for managing Active Record database
@@ -356,7 +360,7 @@ module ActiveRecord
       include ConnectionAdapters::AbstractPool
 
       attr_accessor :automatic_reconnect, :checkout_timeout
-      attr_reader :db_config, :size, :reaper, :pool_config
+      attr_reader :db_config, :size, :reaper, :pool_config, :owner_name
 
       delegate :schema_cache, :schema_cache=, to: :pool_config
 
@@ -371,6 +375,7 @@ module ActiveRecord
 
         @pool_config = pool_config
         @db_config = pool_config.db_config
+        @owner_name = pool_config.connection_specification_name
 
         @checkout_timeout = db_config.checkout_timeout
         @idle_timeout = db_config.idle_timeout
@@ -381,7 +386,7 @@ module ActiveRecord
         # registry of which thread owns which connection. Connection ownership is tracked by
         # the +connection.owner+ attr on each +connection+ instance.
         # The invariant works like this: if there is mapping of <tt>thread => conn</tt>,
-        # then that +thread+ does indeed own that +conn+. However, an absence of a such
+        # then that +thread+ does indeed own that +conn+. However, an absence of such
         # mapping does not mean that the +thread+ doesn't own the said connection. In
         # that case +conn.owner+ attr should be consulted.
         # Access and modification of <tt>@thread_cached_conns</tt> does not require

data/lib/active_record/connection_adapters/abstract/transaction.rb

@@ -317,25 +317,31 @@ module ActiveRecord
           end
           raise
         ensure
-          if !error && transaction
-            if Thread.current.status == "aborting"
-              rollback_transaction
+          if transaction
+            if error
+              # @connection still holds an open transaction, so we must not
+              # put it back in the pool for reuse
+              @connection.throw_away! unless transaction.state.rolledback?
             else
-              if !completed && transaction.written
-                ActiveSupport::Deprecation.warn(<<~EOW)
-                  Using `return`, `break` or `throw` to exit a transaction block is
-                  deprecated without replacement. If the `throw` came from
-                  `Timeout.timeout(duration)`, pass an exception class as a second
-                  argument so it doesn't use `throw` to abort its block. This results
-                  in the transaction being committed, but in the next release of Rails
-                  it will rollback.
-                EOW
-              end
-              begin
-                commit_transaction
-              rescue Exception
-                rollback_transaction(transaction) unless transaction.state.completed?
-                raise
+              if Thread.current.status == "aborting"
+                rollback_transaction
+              else
+                if !completed && transaction.written
+                  ActiveSupport::Deprecation.warn(<<~EOW)
+                    Using `return`, `break` or `throw` to exit a transaction block is
+                    deprecated without replacement. If the `throw` came from
+                    `Timeout.timeout(duration)`, pass an exception class as a second
+                    argument so it doesn't use `throw` to abort its block. This results
+                    in the transaction being committed, but in the next release of Rails
+                    it will rollback.
+                  EOW
+                end
+                begin
+                  commit_transaction
+                rescue Exception
+                  rollback_transaction(transaction) unless transaction.state.completed?
+                  raise
+                end
               end
             end
           end

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -113,14 +113,20 @@ module ActiveRecord
 
       # Determines whether writes are currently being prevents.
       #
-      # Returns true if the connection is a replica, or if +prevent_writes+
-      # is set to true.
+      # Returns true if the connection is a replica.
+      #
+      # If the application is using legacy handling, returns
+      # true if `connection_handler.prevent_writes` is set.
+      #
+      # If the application is using the new connection handling
+      # will return true based on `current_preventing_writes`.
       def preventing_writes?
-        if ActiveRecord::Base.legacy_connection_handling
-          replica? || ActiveRecord::Base.connection_handler.prevent_writes
-        else
-          replica? || ActiveRecord::Base.current_preventing_writes
-        end
+        return true if replica?
+        return ActiveRecord::Base.connection_handler.prevent_writes if ActiveRecord::Base.legacy_connection_handling
+        return false if owner_name.nil?
+
+        klass = self.owner_name.safe_constantize
+        klass&.current_preventing_writes
       end
 
       def migrations_paths # :nodoc:
@@ -196,6 +202,10 @@ module ActiveRecord
         @owner = Thread.current
       end
 
+      def owner_name # :nodoc:
+        @pool.owner_name
+      end
+
       def schema_cache
         @pool.get_schema_cache(self)
       end
@@ -501,6 +511,12 @@ module ActiveRecord
         # this should be overridden by concrete adapters
       end
 
+      # Removes the connection from the pool and disconnect it.
+      def throw_away!
+        pool.remove self
+        disconnect!
+      end
+
       # Clear any caching the database adapter may be doing.
       def clear_cache!
         @lock.synchronize { @statements.clear } if @statements

data/lib/active_record/connection_adapters/mysql/schema_creation.rb

@@ -45,10 +45,9 @@ module ActiveRecord
           end
 
           def add_table_options!(create_sql, o)
-            create_sql = super
             create_sql << " DEFAULT CHARSET=#{o.charset}" if o.charset
             create_sql << " COLLATE=#{o.collation}" if o.collation
-            add_sql_comment!(create_sql, o.comment)
+            add_sql_comment!(super, o.comment)
           end
 
           def add_column_options!(sql, options)

data/lib/active_record/core.rb

@@ -166,10 +166,18 @@ module ActiveRecord
       end
 
       def self.connection_handlers
+        unless legacy_connection_handling
+          raise NotImplementedError, "The new connection handling does not support accessing multiple connection handlers."
+        end
+
         @@connection_handlers ||= {}
       end
 
       def self.connection_handlers=(handlers)
+        unless legacy_connection_handling
+          raise NotImplementedError, "The new connection handling does not setting support multiple connection handlers."
+        end
+
         @@connection_handlers = handlers
       end
 
@@ -324,7 +332,7 @@ module ActiveRecord
         hash = args.first
         return super unless Hash === hash
 
-        values = hash.values.map! { |value| value.is_a?(Base) ? value.id : value }
+        values = hash.values.map! { |value| value.respond_to?(:id) ? value.id : value }
         return super if values.any? { |v| StatementCache.unsupported_value?(v) }
 
         keys = hash.keys.map! do |key|

data/lib/active_record/gem_version.rb

@@ -10,7 +10,7 @@ module ActiveRecord
     MAJOR = 6
     MINOR = 1
     TINY  = 0
-    PRE   = "rc1"
+    PRE   = "rc2"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/insert_all.rb

@@ -69,6 +69,8 @@ module ActiveRecord
       attr_reader :scope_attributes
 
       def find_unique_index_for(unique_by)
+        return unique_by if !connection.supports_insert_conflict_target?
+
         name_or_columns = unique_by || model.primary_key
         match = Array(name_or_columns).map(&:to_s)
 

data/lib/active_record/internal_metadata.rb

@@ -43,11 +43,9 @@ module ActiveRecord
       def create_table
         return unless enabled?
 
-        unless table_exists?
-          key_options = connection.internal_string_options_for_primary_key
-
+        unless connection.table_exists?(table_name)
           connection.create_table(table_name, id: false) do |t|
-            t.string :key, **key_options
+            t.string :key, **connection.internal_string_options_for_primary_key
             t.string :value
             t.timestamps
           end

data/lib/active_record/model_schema.rb

@@ -297,6 +297,35 @@ module ActiveRecord
 
       # Sets the columns names the model should ignore. Ignored columns won't have attribute
       # accessors defined, and won't be referenced in SQL queries.
+      #
+      # A common usage pattern for this method is to ensure all references to an attribute
+      # have been removed and deployed, before a migration to drop the column from the database
+      # has been deployed and run. Using this two step approach to dropping columns ensures there
+      # is no code that raises errors due to having a cached schema in memory at the time the
+      # schema migration is run.
+      #
+      # For example, given a model where you want to drop the "category" attribute, first mark it
+      # as ignored:
+      #
+      #   class Project < ActiveRecord::Base
+      #     # schema:
+      #     #   id         :bigint
+      #     #   name       :string, limit: 255
+      #     #   category   :string, limit: 255
+      #
+      #     self.ignored_columns = [:category]
+      #   end
+      #
+      # The schema still contains `category`, but now the model omits it, so any meta-driven code or
+      # schema caching will not attempt to use the column:
+      #
+      #   Project.columns_hash["category"] => nil
+      #
+      # You will get an error if accessing that attribute directly, so ensure all usages of the
+      # column are removed (automated tests can help you find any usages).
+      #
+      #   user = Project.create!(name: "First Project")
+      #   user.category # => raises NoMethodError
       def ignored_columns=(columns)
         reload_schema_from_cache
         @ignored_columns = columns.map(&:to_s).freeze

data/lib/active_record/railtie.rb

@@ -183,7 +183,7 @@ To keep using the current cache store, you can turn off cache versioning entirel
                 end
               end
             rescue ActiveRecordError => error
-              # Regardless of wether there was already a connection or not, we rescue any database
+              # Regardless of whether there was already a connection or not, we rescue any database
               # error because it is critical that the application can boot even if the database
               # is unhealthy.
               warn "Failed to define attribute methods because of #{error.class}: #{error.message}"

data/lib/active_record/railties/databases.rake

@@ -455,6 +455,14 @@ db_namespace = namespace :db do
       ActiveRecord::Tasks::DatabaseTasks.load_schema_current(ActiveRecord::Base.schema_format, ENV["SCHEMA"])
     end
 
+    task load_if_ruby: ["db:create", :environment] do
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+        Using `bin/rails db:schema:load_if_ruby` is deprecated and will be removed in Rails 6.2.
+        Configure the format using `config.active_record.schema_format = :ruby` to use `schema.rb` and run `bin/rails db:schema:load` instead.
+      MSG
+      db_namespace["schema:load"].invoke if ActiveRecord::Base.schema_format == :ruby
+    end
+
     namespace :dump do
       ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
         desc "Creates a database schema file (either db/schema.rb or db/structure.sql, depending on `config.active_record.schema_format`) for #{name} database"
@@ -529,6 +537,14 @@ db_namespace = namespace :db do
       db_namespace["schema:load"].invoke
     end
 
+    task load_if_sql: ["db:create", :environment] do
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+        Using `bin/rails db:structure:load_if_sql` is deprecated and will be removed in Rails 6.2.
+        Configure the format using `config.active_record.schema_format = :sql` to use `structure.sql` and run `bin/rails db:schema:load` instead.
+      MSG
+      db_namespace["schema:load"].invoke if ActiveRecord::Base.schema_format == :sql
+    end
+
     namespace :dump do
       ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
         desc "Dumps the #{name} database structure to db/structure.sql. Specify another file with SCHEMA=db/my_structure.sql"

data/lib/active_record/reflection.rb

@@ -623,6 +623,7 @@ module ActiveRecord
         # with the current reflection's klass name.
         def valid_inverse_reflection?(reflection)
           reflection &&
+            foreign_key == reflection.foreign_key &&
             klass <= reflection.active_record &&
             can_find_inverse_of_automatically?(reflection)
         end

data/lib/active_record/relation/predicate_builder.rb

@@ -59,7 +59,7 @@ module ActiveRecord
     end
 
     def build(attribute, value, operator = nil)
-      value = value.id if value.is_a?(Base)
+      value = value.id if value.respond_to?(:id)
       if operator ||= table.type(attribute.name).force_equality?(value) && :eq
         bind = build_bind_attribute(attribute.name, value)
         attribute.public_send(operator, bind)
@@ -100,7 +100,7 @@ module ActiveRecord
               end
             elsif associated_table.through_association?
               next associated_table.predicate_builder.expand_from_hash(
-                associated_table.join_foreign_key => value
+                associated_table.primary_key => value
               )
             end
 

data/lib/active_record/relation/predicate_builder/association_query_value.rb

@@ -31,9 +31,8 @@ module ActiveRecord
         end
 
         def convert_to_id(value)
-          case value
-          when Base
-            value._read_attribute(primary_key)
+          if value.respond_to?(:id)
+            value.id
           else
             value
           end

data/lib/active_record/relation/spawn_methods.rb

@@ -69,8 +69,8 @@ module ActiveRecord
 
     private
       def relation_with(values)
-        result = Relation.create(klass, values: values)
-        result.extend(*extending_values) if extending_values.any?
+        result = spawn
+        result.instance_variable_set(:@values, values)
         result
       end
   end

data/lib/active_record/schema_migration.rb

@@ -23,11 +23,9 @@ module ActiveRecord
       end
 
       def create_table
-        unless table_exists?
-          version_options = connection.internal_string_options_for_primary_key
-
+        unless connection.table_exists?(table_name)
           connection.create_table(table_name, id: false) do |t|
-            t.string :version, **version_options
+            t.string :version, **connection.internal_string_options_for_primary_key
           end
         end
       end

data/lib/active_record/table_metadata.rb

@@ -10,6 +10,10 @@ module ActiveRecord
       @reflection = reflection
     end
 
+    def primary_key
+      klass&.primary_key
+    end
+
     def type(column_name)
       arel_table.type_for_attribute(column_name)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord
 version: !ruby/object:Gem::Version
-  version: 6.1.0.rc1
+  version: 6.1.0.rc2
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-02 00:00:00.000000000 Z
+date: 2020-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.1.0.rc1
+        version: 6.1.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.1.0.rc1
+        version: 6.1.0.rc2
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.1.0.rc1
+        version: 6.1.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.1.0.rc1
+        version: 6.1.0.rc2
 description: Databases on Rails. Build a persistent domain model by mapping database
   tables to Ruby classes. Strong conventions for associations, validations, aggregations,
   migrations, and testing come baked-in.
@@ -390,10 +390,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v6.1.0.rc1/activerecord/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v6.1.0.rc1/
+  changelog_uri: https://github.com/rails/rails/blob/v6.1.0.rc2/activerecord/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v6.1.0.rc2/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v6.1.0.rc1/activerecord
+  source_code_uri: https://github.com/rails/rails/tree/v6.1.0.rc2/activerecord
 post_install_message: 
 rdoc_options:
 - "--main"