activerecord 7.2.0.beta2 → 7.2.0.rc1

data/lib/active_record/relation/query_methods.rb

@@ -173,7 +173,7 @@ module ActiveRecord
         end                                    # end
 
         def #{method_name}=(value)             # def includes_values=(value)
-          assert_mutability!                   #   assert_mutability!
+          assert_modifiable!                   #   assert_modifiable!
           @values[:#{name}] = value            #   @values[:includes] = value
         end                                    # end
       CODE
@@ -796,7 +796,7 @@ module ActiveRecord
           if !VALID_UNSCOPING_VALUES.include?(scope)
             raise ArgumentError, "Called unscope() with invalid unscoping argument ':#{scope}'. Valid arguments are :#{VALID_UNSCOPING_VALUES.to_a.join(", :")}."
           end
-          assert_mutability!
+          assert_modifiable!
           @values.delete(scope)
         when Hash
           scope.each do |key, target_value|
@@ -1705,8 +1705,8 @@ module ActiveRecord
         )
       end
 
-      def assert_mutability!
-        raise ImmutableRelation if @loaded || @arel
+      def assert_modifiable!
+        raise UnmodifiableRelation if @loaded || @arel
       end
 
       def build_arel(connection, aliases = nil)
@@ -2063,17 +2063,29 @@ module ActiveRecord
         order_args.flat_map do |arg|
           case arg
           when String, Symbol
-            arg
+            extract_table_name_from(arg)
           when Hash
-            arg.keys.select { |e| e.is_a?(String) || e.is_a?(Symbol) }
+            arg
+              .map do |key, value|
+                case value
+                when Hash
+                  key.to_s
+                else
+                  extract_table_name_from(key) if key.is_a?(String) || key.is_a?(Symbol)
+                end
+              end
+          when Arel::Attribute
+            arg.relation.name
+          when Arel::Nodes::Ordering
+            if arg.expr.is_a?(Arel::Attribute)
+              arg.expr.relation.name
+            end
           end
-        end.filter_map do |arg|
-          arg =~ /^\W?(\w+)\W?\./ && $1
-        end +
-        order_args
-          .select { |e| e.is_a?(Hash) }
-          .flat_map { |e| e.map { |k, v| k if v.is_a?(Hash) } }
-          .compact
+        end.compact
+      end
+
+      def extract_table_name_from(string)
+        string.match(/^\W?(\w+)\W?\./) && $1
       end
 
       def order_column(field)

data/lib/active_record/signed_id.rb

@@ -106,7 +106,16 @@ module ActiveRecord
 
 
     # 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.
+    # However, as with any message signed with a +ActiveSupport::MessageVerifier+,
+    # {the signed id is not encrypted}[link:classes/ActiveSupport/MessageVerifier.html#class-ActiveSupport::MessageVerifier-label-Signing+is+not+encryption].
+    # It's just encoded and protected against tampering.
+    #
+    # This means that the ID can be decoded by anyone; however, if tampered with (so to point to a different ID),
+    # the cryptographic signature will no longer match, and the signed id will be considered invalid and return nil
+    # when passed to +find_signed+ (or raise with +find_signed!+).
+    #
     # It can furthermore 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.

data/lib/active_record/tasks/database_tasks.rb

@@ -192,9 +192,17 @@ module ActiveRecord
 
               seed = true
             end
+          end
+        end
 
-            migrate
-            dump_schema(db_config) if ActiveRecord.dump_schema_after_migration
+        each_current_environment(env) do |environment|
+          db_configs_with_versions(environment).sort.each do |version, db_configs|
+            db_configs.each do |db_config|
+              with_temporary_pool(db_config) do
+                migrate(version)
+                dump_schema(db_config) if ActiveRecord.dump_schema_after_migration
+              end
+            end
           end
         end
 
@@ -255,10 +263,10 @@ module ActiveRecord
         Migration.verbose = verbose_was
       end
 
-      def db_configs_with_versions # :nodoc:
+      def db_configs_with_versions(environment = env) # :nodoc:
         db_configs_with_versions = Hash.new { |h, k| h[k] = [] }
 
-        with_temporary_pool_for_each do |pool|
+        with_temporary_pool_for_each(env: environment) do |pool|
           db_config = pool.db_config
           versions_to_run = pool.migration_context.pending_migration_versions
           target_version = ActiveRecord::Tasks::DatabaseTasks.target_version
@@ -580,10 +588,7 @@ module ActiveRecord
         end
 
         def each_current_configuration(environment, name = nil)
-          environments = [environment]
-          environments << "test" if environment == "development" && !ENV["SKIP_TEST_DATABASE"] && !ENV["DATABASE_URL"]
-
-          environments.each do |env|
+          each_current_environment(environment) do |env|
             configs_for(env_name: env).each do |db_config|
               next if name && name != db_config.name
 
@@ -592,6 +597,12 @@ module ActiveRecord
           end
         end
 
+        def each_current_environment(environment, &block)
+          environments = [environment]
+          environments << "test" if environment == "development" && !ENV["SKIP_TEST_DATABASE"] && !ENV["DATABASE_URL"]
+          environments.each(&block)
+        end
+
         def each_local_configuration
           configs_for.each do |db_config|
             next unless db_config.database

data/lib/active_record/test_fixtures.rb

@@ -96,6 +96,14 @@ module ActiveRecord
       end
     end
 
+    # Generic fixture accessor for fixture names that may conflict with other methods.
+    #
+    #   assert_equal "Ruby on Rails", web_sites(:rubyonrails).name
+    #   assert_equal "Ruby on Rails", fixture(:web_sites, :rubyonrails).name
+    def fixture(fixture_set_name, *fixture_names)
+      active_record_fixture(fixture_set_name, *fixture_names)
+    end
+
     private
       def run_in_transaction?
         use_transactional_tests &&
@@ -255,7 +263,7 @@ module ActiveRecord
 
       def method_missing(method, ...)
         if fixture_sets.key?(method.name)
-          _active_record_fixture(method, ...)
+          active_record_fixture(method, ...)
         else
           super
         end
@@ -269,14 +277,13 @@ module ActiveRecord
         end
       end
 
-      def _active_record_fixture(fixture_set_name, *fixture_names)
+      def active_record_fixture(fixture_set_name, *fixture_names)
         if fs_name = fixture_sets[fixture_set_name.name]
           access_fixture(fs_name, *fixture_names)
         else
           raise StandardError, "No fixture set named '#{fixture_set_name.inspect}'"
         end
       end
-      alias_method :fixture, :_active_record_fixture
 
       def access_fixture(fs_name, *fixture_names)
         force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload

data/lib/active_record/timestamp.rb

@@ -162,7 +162,7 @@ module ActiveRecord
 
     def max_updated_column_timestamp
       timestamp_attributes_for_update_in_model
-        .filter_map { |attr| self[attr]&.to_time }
+        .filter_map { |attr| (v = self[attr]) && (v.is_a?(::Time) ? v : v.to_time) }
         .max
     end
 

data/lib/active_record/transaction.rb

@@ -3,9 +3,30 @@
 require "active_support/core_ext/digest"
 
 module ActiveRecord
-  # This abstract class specifies the interface to interact with the current transaction state.
+  # Class specifies the interface to interact with the current transaction state.
   #
-  # Any other methods not specified here are considered to be private interfaces.
+  # It can either map to an actual transaction/savepoint, or represent the
+  # absence of a transaction.
+  #
+  # == State
+  #
+  # We say that a transaction is _finalized_ when it wraps a real transaction
+  # that has been either committed or rolled back.
+  #
+  # A transaction is _open_ if it wraps a real transaction that is not finalized.
+  #
+  # On the other hand, a transaction is _closed_ when it is not open. That is,
+  # when it represents absence of transaction, or it wraps a real but finalized
+  # one.
+  #
+  # You can check whether a transaction is open or closed with the +open?+ and
+  # +closed?+ predicates:
+  #
+  #  if Article.current_transaction.open?
+  #    # We are inside a real and not finalized transaction.
+  #  end
+  #
+  # Closed transactions are `blank?` too.
   #
   # == Callbacks
   #
@@ -42,90 +63,70 @@ module ActiveRecord
   # == Caveats
   #
   # When using after_commit callbacks, it is important to note that if the callback raises an error, the transaction
-  # won't be rolled back. Relying solely on these to synchronize state between multiple systems may lead to consistency issues.
+  # won't be rolled back as it was already committed. Relying solely on these to synchronize state between multiple
+  # systems may lead to consistency issues.
   class Transaction
-    class Callback # :nodoc:
-      def initialize(event, callback)
-        @event = event
-        @callback = callback
-      end
-
-      def before_commit
-        @callback.call if @event == :before_commit
-      end
-
-      def after_commit
-        @callback.call if @event == :after_commit
-      end
-
-      def after_rollback
-        @callback.call if @event == :after_rollback
-      end
-    end
-
-    def initialize # :nodoc:
-      @callbacks = nil
+    def initialize(internal_transaction) # :nodoc:
+      @internal_transaction = internal_transaction
       @uuid = nil
     end
 
-    # Registers a block to be called before the current transaction is fully committed.
-    #
-    # If there is no currently open transactions, the block is called immediately.
-    #
-    # If the current transaction has a parent transaction, the callback is transferred to
-    # the parent when the current transaction commits, or dropped when the current transaction
-    # is rolled back. This operation is repeated until the outermost transaction is reached.
-    #
-    # If the callback raises an error, the transaction is rolled back.
-    def before_commit(&block)
-      (@callbacks ||= []) << Callback.new(:before_commit, block)
-    end
-
-    # Registers a block to be called after the current transaction is fully committed.
+    # Registers a block to be called after the transaction is fully committed.
     #
-    # If there is no currently open transactions, the block is called immediately.
+    # If there is no currently open transactions, the block is called
+    # immediately, unless the transaction is finalized, in which case attempting
+    # to register the callback raises ActiveRecord::ActiveRecordError.
     #
-    # If the current transaction has a parent transaction, the callback is transferred to
+    # If the transaction has a parent transaction, the callback is transferred to
     # the parent when the current transaction commits, or dropped when the current transaction
     # is rolled back. This operation is repeated until the outermost transaction is reached.
     #
     # If the callback raises an error, the transaction remains committed.
     def after_commit(&block)
-      (@callbacks ||= []) << Callback.new(:after_commit, block)
+      if @internal_transaction.nil?
+        yield
+      else
+        @internal_transaction.after_commit(&block)
+      end
     end
 
-    # Registers a block to be called after the current transaction is rolled back.
+    # Registers a block to be called after the transaction is rolled back.
     #
-    # If there is no currently open transactions, the block is never called.
+    # If there is no currently open transactions, the block is not called. But
+    # if the transaction is finalized, attempting to register the callback
+    # raises ActiveRecord::ActiveRecordError.
     #
-    # If the current transaction is successfully committed but has a parent
+    # If the transaction is successfully committed but has a parent
     # transaction, the callback is automatically added to the parent transaction.
     #
     # If the entire chain of nested transactions are all successfully committed,
     # the block is never called.
+    #
+    # If the transaction is already finalized, attempting to register a callback
+    # will raise ActiveRecord::ActiveRecordError.
     def after_rollback(&block)
-      (@callbacks ||= []) << Callback.new(:after_rollback, block)
+      @internal_transaction&.after_rollback(&block)
     end
 
-    # Returns true if a transaction was started.
+    # Returns true if the transaction exists and isn't finalized yet.
     def open?
-      true
+      !closed?
     end
 
-    # Returns true if no transaction is currently active.
+    # Returns true if the transaction doesn't exist or is finalized.
     def closed?
-      false
+      @internal_transaction.nil? || @internal_transaction.state.finalized?
     end
+
     alias_method :blank?, :closed?
 
-    # Returns a UUID for this transaction.
+    # Returns a UUID for this transaction or +nil+ if no transaction is open.
     def uuid
-      @uuid ||= Digest::UUID.uuid_v4
+      if @internal_transaction
+        @uuid ||= Digest::UUID.uuid_v4
+      end
     end
 
-    protected
-      def append_callbacks(callbacks) # :nodoc:
-        (@callbacks ||= []).concat(callbacks)
-      end
+    NULL_TRANSACTION = new(nil).freeze
   end
 end

data/lib/active_record/transactions.rb

@@ -243,7 +243,7 @@ module ActiveRecord
       #
       # See the ActiveRecord::Transaction documentation for detailed behavior.
       def current_transaction
-        connection_pool.active_connection&.current_transaction || ConnectionAdapters::TransactionManager::NULL_TRANSACTION
+        connection_pool.active_connection&.current_transaction&.user_transaction || Transaction::NULL_TRANSACTION
       end
 
       def before_commit(*args, &block) # :nodoc:

data/lib/active_record.rb

@@ -290,7 +290,7 @@ module ActiveRecord
   # with the global thread pool async query executor.
   def self.global_executor_concurrency=(global_executor_concurrency)
     if self.async_query_executor.nil? || self.async_query_executor == :multi_thread_pool
-      raise ArgumentError, "`global_executor_concurrency` cannot be set when using the executor is nil or set to multi_thead_pool. For multiple thread pools, please set the concurrency in your database configuration."
+      raise ArgumentError, "`global_executor_concurrency` cannot be set when the executor is nil or set to `:multi_thread_pool`. For multiple thread pools, please set the concurrency in your database configuration."
     end
 
     @global_executor_concurrency = global_executor_concurrency

data/lib/rails/generators/active_record/migration/templates/create_table_migration.rb.tt

@@ -12,7 +12,10 @@ class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Mi
       t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
 <% end -%>
 <% end -%>
-<% if options[:timestamps] %>
+<% unless attributes.empty? -%>
+
+<% end -%>
+<% if options[:timestamps] -%>
       t.timestamps
 <% end -%>
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord
 version: !ruby/object:Gem::Version
-  version: 7.2.0.beta2
+  version: 7.2.0.rc1
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-04 00:00:00.000000000 Z
+date: 2024-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.2.0.beta2
+        version: 7.2.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.2.0.beta2
+        version: 7.2.0.rc1
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.2.0.beta2
+        version: 7.2.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.2.0.beta2
+        version: 7.2.0.rc1
 - !ruby/object:Gem::Dependency
   name: timeout
   requirement: !ruby/object:Gem::Requirement
@@ -85,6 +85,7 @@ files:
 - lib/active_record/associations/collection_association.rb
 - lib/active_record/associations/collection_proxy.rb
 - lib/active_record/associations/disable_joins_association_scope.rb
+- lib/active_record/associations/errors.rb
 - lib/active_record/associations/foreign_association.rb
 - lib/active_record/associations/has_many_association.rb
 - lib/active_record/associations/has_many_through_association.rb
@@ -475,10 +476,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v7.2.0.beta2/activerecord/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v7.2.0.beta2/
+  changelog_uri: https://github.com/rails/rails/blob/v7.2.0.rc1/activerecord/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v7.2.0.rc1/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v7.2.0.beta2/activerecord
+  source_code_uri: https://github.com/rails/rails/tree/v7.2.0.rc1/activerecord
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options:
@@ -493,11 +494,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.3.27
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: Object-relational mapper framework (part of Rails).