activerecord 6.1.3.2 → 7.0.0.alpha2

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -94,7 +94,7 @@ module ActiveRecord
             sslcapath: "--ssl-capath",
             sslcipher: "--ssl-cipher",
             sslkey:    "--ssl-key"
-          }.map { |opt, arg| "#{arg}=#{configuration_hash[opt]}" if configuration_hash[opt] }.compact
+          }.filter_map { |opt, arg| "#{arg}=#{configuration_hash[opt]}" if configuration_hash[opt] }
 
           args
         end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -47,16 +47,14 @@ module ActiveRecord
       end
 
       def structure_dump(filename, extra_flags)
-        set_psql_env
-
         search_path = \
-          case ActiveRecord::Base.dump_schemas
+          case ActiveRecord.dump_schemas
           when :schema_search_path
             configuration_hash[:schema_search_path]
           when :all
             nil
           when String
-            ActiveRecord::Base.dump_schemas
+            ActiveRecord.dump_schemas
           end
 
         args = ["--schema-only", "--no-privileges", "--no-owner", "--file", filename]
@@ -79,7 +77,6 @@ module ActiveRecord
       end
 
       def structure_load(filename, extra_flags)
-        set_psql_env
         args = ["--set", ON_ERROR_STOP_1, "--quiet", "--no-psqlrc", "--file", filename]
         args.concat(Array(extra_flags)) if extra_flags
         args << db_config.database
@@ -100,15 +97,21 @@ module ActiveRecord
           )
         end
 
-        def set_psql_env
-          ENV["PGHOST"]     = db_config.host                     if db_config.host
-          ENV["PGPORT"]     = configuration_hash[:port].to_s     if configuration_hash[:port]
-          ENV["PGPASSWORD"] = configuration_hash[:password].to_s if configuration_hash[:password]
-          ENV["PGUSER"]     = configuration_hash[:username].to_s if configuration_hash[:username]
+        def psql_env
+          {}.tap do |env|
+            env["PGHOST"]         = db_config.host                        if db_config.host
+            env["PGPORT"]         = configuration_hash[:port].to_s        if configuration_hash[:port]
+            env["PGPASSWORD"]     = configuration_hash[:password].to_s    if configuration_hash[:password]
+            env["PGUSER"]         = configuration_hash[:username].to_s    if configuration_hash[:username]
+            env["PGSSLMODE"]      = configuration_hash[:sslmode].to_s     if configuration_hash[:sslmode]
+            env["PGSSLCERT"]      = configuration_hash[:sslcert].to_s     if configuration_hash[:sslcert]
+            env["PGSSLKEY"]       = configuration_hash[:sslkey].to_s      if configuration_hash[:sslkey]
+            env["PGSSLROOTCERT"]  = configuration_hash[:sslrootcert].to_s if configuration_hash[:sslrootcert]
+          end
         end
 
         def run_cmd(cmd, args, action)
-          fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
+          fail run_cmd_error(cmd, args, action) unless Kernel.system(psql_env, cmd, *args)
         end
 
         def run_cmd_error(cmd, args, action)

data/lib/active_record/test_databases.rb

@@ -14,7 +14,7 @@ module ActiveRecord
       ActiveRecord::Base.configurations.configs_for(env_name: env_name).each do |db_config|
         db_config._database = "#{db_config.database}-#{i}"
 
-        ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config, ActiveRecord::Base.schema_format, nil)
+        ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config, ActiveRecord.schema_format, nil)
       end
     ensure
       ActiveRecord::Base.establish_connection

data/lib/active_record/test_fixtures.rb

@@ -111,6 +111,8 @@ module ActiveRecord
       @fixture_connections = []
       @@already_loaded_fixtures ||= {}
       @connection_subscriber = nil
+      @legacy_saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
+      @saved_pool_configs = Hash.new { |hash, key| hash[key] = {} }
 
       # Load fixtures once and begin transaction.
       if run_in_transaction?
@@ -169,6 +171,7 @@ module ActiveRecord
           connection.pool.lock_thread = false
         end
         @fixture_connections.clear
+        teardown_shared_connection_pool
       else
         ActiveRecord::FixtureSet.reset_cache
       end
@@ -190,8 +193,8 @@ module ActiveRecord
       # need to share a connection pool so that the reading connection
       # can see data in the open transaction on the writing connection.
       def setup_shared_connection_pool
-        if ActiveRecord::Base.legacy_connection_handling
-          writing_handler = ActiveRecord::Base.connection_handlers[ActiveRecord::Base.writing_role]
+        if ActiveRecord.legacy_connection_handling
+          writing_handler = ActiveRecord::Base.connection_handlers[ActiveRecord.writing_role]
 
           ActiveRecord::Base.connection_handlers.values.each do |handler|
             if handler != writing_handler
@@ -200,8 +203,13 @@ module ActiveRecord
                 return unless writing_pool_manager
 
                 pool_manager = handler.send(:owner_to_pool_manager)[name]
+                @legacy_saved_pool_configs[handler][name] ||= {}
                 pool_manager.shard_names.each do |shard_name|
                   writing_pool_config = writing_pool_manager.get_pool_config(nil, shard_name)
+                  pool_config = pool_manager.get_pool_config(nil, shard_name)
+                  next if pool_config == writing_pool_config
+
+                  @legacy_saved_pool_configs[handler][name][shard_name] = pool_config
                   pool_manager.set_pool_config(nil, shard_name, writing_pool_config)
                 end
               end
@@ -213,9 +221,13 @@ module ActiveRecord
           handler.connection_pool_names.each do |name|
             pool_manager = handler.send(:owner_to_pool_manager)[name]
             pool_manager.shard_names.each do |shard_name|
-              writing_pool_config = pool_manager.get_pool_config(ActiveRecord::Base.writing_role, shard_name)
+              writing_pool_config = pool_manager.get_pool_config(ActiveRecord.writing_role, shard_name)
+              @saved_pool_configs[name][shard_name] ||= {}
               pool_manager.role_names.each do |role|
-                next unless pool_manager.get_pool_config(role, shard_name)
+                next unless pool_config = pool_manager.get_pool_config(role, shard_name)
+                next if pool_config == writing_pool_config
+
+                @saved_pool_configs[name][shard_name][role] = pool_config
                 pool_manager.set_pool_config(role, shard_name, writing_pool_config)
               end
             end
@@ -223,6 +235,35 @@ module ActiveRecord
         end
       end
 
+      def teardown_shared_connection_pool
+        if ActiveRecord.legacy_connection_handling
+          @legacy_saved_pool_configs.each_pair do |handler, names|
+            names.each_pair do |name, shards|
+              shards.each_pair do |shard_name, pool_config|
+                pool_manager = handler.send(:owner_to_pool_manager)[name]
+                pool_manager.set_pool_config(nil, shard_name, pool_config)
+              end
+            end
+          end
+        else
+          handler = ActiveRecord::Base.connection_handler
+
+          @saved_pool_configs.each_pair do |name, shards|
+            pool_manager = handler.send(:owner_to_pool_manager)[name]
+            shards.each_pair do |shard_name, roles|
+              roles.each_pair do |role, pool_config|
+                next unless pool_manager.get_pool_config(role, shard_name)
+
+                pool_manager.set_pool_config(role, shard_name, pool_config)
+              end
+            end
+          end
+        end
+
+        @legacy_saved_pool_configs.clear
+        @saved_pool_configs.clear
+      end
+
       def load_fixtures(config)
         ActiveRecord::FixtureSet.create_fixtures(fixture_path, fixture_table_names, fixture_class_names, config).index_by(&:name)
       end

data/lib/active_record/timestamp.rb

@@ -75,7 +75,7 @@ module ActiveRecord
       end
 
       def current_time_from_proper_timezone
-        default_timezone == :utc ? Time.now.utc : Time.now
+        ActiveRecord.default_timezone == :utc ? Time.now.utc : Time.now
       end
 
       private
@@ -127,7 +127,7 @@ module ActiveRecord
     end
 
     def should_record_timestamps?
-      record_timestamps && (!partial_writes? || has_changes_to_save?)
+      record_timestamps && (!partial_updates? || has_changes_to_save?)
     end
 
     def timestamp_attributes_for_create_in_model
@@ -148,8 +148,7 @@ module ActiveRecord
 
     def max_updated_column_timestamp
       timestamp_attributes_for_update_in_model
-        .map { |attr| self[attr]&.to_time }
-        .compact
+        .filter_map { |attr| self[attr]&.to_time }
         .max
     end
 

data/lib/active_record/transactions.rb

@@ -4,7 +4,7 @@ module ActiveRecord
   # See ActiveRecord::Transactions::ClassMethods for documentation.
   module Transactions
     extend ActiveSupport::Concern
-    #:nodoc:
+    # :nodoc:
     ACTIONS = [:create, :destroy, :update]
 
     included do
@@ -290,19 +290,19 @@ module ActiveRecord
       self.class.transaction(**options, &block)
     end
 
-    def destroy #:nodoc:
+    def destroy # :nodoc:
       with_transaction_returning_status { super }
     end
 
-    def save(**) #:nodoc:
+    def save(**) # :nodoc:
       with_transaction_returning_status { super }
     end
 
-    def save!(**) #:nodoc:
+    def save!(**) # :nodoc:
       with_transaction_returning_status { super }
     end
 
-    def touch(*, **) #:nodoc:
+    def touch(*, **) # :nodoc:
       with_transaction_returning_status { super }
     end
 
@@ -314,8 +314,8 @@ module ActiveRecord
     #
     # Ensure that it is not called if the object was never persisted (failed create),
     # but call it after the commit of a destroyed object.
-    def committed!(should_run_callbacks: true) #:nodoc:
-      force_clear_transaction_record_state
+    def committed!(should_run_callbacks: true) # :nodoc:
+      @_start_transaction_state = nil
       if should_run_callbacks
         @_committed_already_called = true
         _run_commit_callbacks
@@ -326,7 +326,7 @@ module ActiveRecord
 
     # Call the #after_rollback callbacks. The +force_restore_state+ argument indicates if the record
     # state should be rolled back to the beginning or just to the last savepoint.
-    def rolledback!(force_restore_state: false, should_run_callbacks: true) #:nodoc:
+    def rolledback!(force_restore_state: false, should_run_callbacks: true) # :nodoc:
       if should_run_callbacks
         _run_rollback_callbacks
       end
@@ -389,12 +389,7 @@ module ActiveRecord
       def clear_transaction_record_state
         return unless @_start_transaction_state
         @_start_transaction_state[:level] -= 1
-        force_clear_transaction_record_state if @_start_transaction_state[:level] < 1
-      end
-
-      # Force to clear the transaction record state.
-      def force_clear_transaction_record_state
-        @_start_transaction_state = nil
+        @_start_transaction_state = nil if @_start_transaction_state[:level] < 1
       end
 
       # Restore the new record state and id of a record that was previously saved by a call to save_record_state.

data/lib/active_record/translation.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     include ActiveModel::Translation
 
     # Set the lookup ancestors for ActiveModel.
-    def lookup_ancestors #:nodoc:
+    def lookup_ancestors # :nodoc:
       klass = self
       classes = [klass]
       return classes if klass == ActiveRecord::Base
@@ -17,7 +17,7 @@ module ActiveRecord
     end
 
     # Set the i18n scope to overwrite ActiveModel.
-    def i18n_scope #:nodoc:
+    def i18n_scope # :nodoc:
       :activerecord
     end
   end

data/lib/active_record/type/adapter_specific_registry.rb

@@ -5,15 +5,40 @@ require "active_model/type/registry"
 module ActiveRecord
   # :stopdoc:
   module Type
-    class AdapterSpecificRegistry < ActiveModel::Type::Registry
+    class AdapterSpecificRegistry # :nodoc:
+      def initialize
+        @registrations = []
+      end
+
+      def initialize_copy(other)
+        @registrations = @registrations.dup
+        super
+      end
+
       def add_modifier(options, klass, **args)
         registrations << DecorationRegistration.new(options, klass, **args)
       end
 
-      private
-        def registration_klass
-          Registration
+      def register(type_name, klass = nil, **options, &block)
+        unless block_given?
+          block = proc { |_, *args| klass.new(*args) }
+          block.ruby2_keywords if block.respond_to?(:ruby2_keywords)
         end
+        registrations << Registration.new(type_name, block, **options)
+      end
+
+      def lookup(symbol, *args, **kwargs)
+        registration = find_registration(symbol, *args, **kwargs)
+
+        if registration
+          registration.call(self, symbol, *args, **kwargs)
+        else
+          raise ArgumentError, "Unknown type #{symbol.inspect}"
+        end
+      end
+
+      private
+        attr_reader :registrations
 
         def find_registration(symbol, *args, **kwargs)
           registrations
@@ -22,7 +47,7 @@ module ActiveRecord
         end
     end
 
-    class Registration
+    class Registration # :nodoc:
       def initialize(name, block, adapter: nil, override: nil)
         @name = name
         @block = block
@@ -89,7 +114,7 @@ module ActiveRecord
         end
     end
 
-    class DecorationRegistration < Registration
+    class DecorationRegistration < Registration # :nodoc:
       def initialize(options, klass, adapter: nil)
         @options = options
         @klass = klass
@@ -120,7 +145,7 @@ module ActiveRecord
     end
   end
 
-  class TypeConflictError < StandardError
+  class TypeConflictError < StandardError # :nodoc:
   end
   # :startdoc:
 end

data/lib/active_record/type/hash_lookup_type_map.rb

@@ -2,7 +2,40 @@
 
 module ActiveRecord
   module Type
-    class HashLookupTypeMap < TypeMap # :nodoc:
+    class HashLookupTypeMap # :nodoc:
+      def initialize(parent = nil)
+        @mapping = {}
+        @cache = Concurrent::Map.new do |h, key|
+          h.fetch_or_store(key, Concurrent::Map.new)
+        end
+      end
+
+      def lookup(lookup_key, *args)
+        fetch(lookup_key, *args) { Type.default_value }
+      end
+
+      def fetch(lookup_key, *args, &block)
+        @cache[lookup_key].fetch_or_store(args) do
+          perform_fetch(lookup_key, *args, &block)
+        end
+      end
+
+      def register_type(key, value = nil, &block)
+        raise ::ArgumentError unless value || block
+
+        if block
+          @mapping[key] = block
+        else
+          @mapping[key] = proc { value }
+        end
+        @cache.clear
+      end
+
+      def clear
+        @mapping.clear
+        @cache.clear
+      end
+
       def alias_type(type, alias_type)
         register_type(type) { |_, *args| lookup(alias_type, *args) }
       end

data/lib/active_record/type/internal/timezone.rb

@@ -5,11 +5,11 @@ module ActiveRecord
     module Internal
       module Timezone
         def is_utc?
-          ActiveRecord::Base.default_timezone == :utc
+          ActiveRecord.default_timezone == :utc
         end
 
         def default_timezone
-          ActiveRecord::Base.default_timezone
+          ActiveRecord.default_timezone
         end
       end
     end

data/lib/active_record/type/serialized.rb

@@ -31,7 +31,7 @@ module ActiveRecord
       end
 
       def inspect
-        Kernel.instance_method(:inspect).bind(self).call
+        Kernel.instance_method(:inspect).bind_call(self)
       end
 
       def changed_in_place?(raw_old_value, value)

data/lib/active_record/type/type_map.rb

@@ -5,55 +5,52 @@ require "concurrent/map"
 module ActiveRecord
   module Type
     class TypeMap # :nodoc:
-      def initialize
+      def initialize(parent = nil)
         @mapping = {}
-        @cache = Concurrent::Map.new do |h, key|
-          h.fetch_or_store(key, Concurrent::Map.new)
-        end
+        @parent = parent
+        @cache = Concurrent::Map.new
       end
 
-      def lookup(lookup_key, *args)
-        fetch(lookup_key, *args) { Type.default_value }
+      def lookup(lookup_key)
+        fetch(lookup_key) { Type.default_value }
       end
 
-      def fetch(lookup_key, *args, &block)
-        @cache[lookup_key].fetch_or_store(args) do
-          perform_fetch(lookup_key, *args, &block)
+      def fetch(lookup_key, &block)
+        @cache.fetch_or_store(lookup_key) do
+          perform_fetch(lookup_key, &block)
         end
       end
 
       def register_type(key, value = nil, &block)
         raise ::ArgumentError unless value || block
-        @cache.clear
 
         if block
           @mapping[key] = block
         else
           @mapping[key] = proc { value }
         end
+        @cache.clear
       end
 
       def alias_type(key, target_key)
-        register_type(key) do |sql_type, *args|
+        register_type(key) do |sql_type|
           metadata = sql_type[/\(.*\)/, 0]
-          lookup("#{target_key}#{metadata}", *args)
+          lookup("#{target_key}#{metadata}")
         end
       end
 
-      def clear
-        @mapping.clear
-      end
-
-      private
-        def perform_fetch(lookup_key, *args)
+      protected
+        def perform_fetch(lookup_key, &block)
           matching_pair = @mapping.reverse_each.detect do |key, _|
             key === lookup_key
           end
 
           if matching_pair
-            matching_pair.last.call(lookup_key, *args)
+            matching_pair.last.call(lookup_key)
+          elsif @parent
+            @parent.perform_fetch(lookup_key, &block)
           else
-            yield lookup_key, *args
+            yield lookup_key
           end
         end
     end