activerecord 4.2.0 → 6.1.7.1

data/lib/active_record/test_fixtures.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+
+module ActiveRecord
+  module TestFixtures
+    extend ActiveSupport::Concern
+
+    def before_setup # :nodoc:
+      setup_fixtures
+      super
+    end
+
+    def after_teardown # :nodoc:
+      super
+      teardown_fixtures
+    end
+
+    included do
+      class_attribute :fixture_path, instance_writer: false
+      class_attribute :fixture_table_names, default: []
+      class_attribute :fixture_class_names, default: {}
+      class_attribute :use_transactional_tests, default: true
+      class_attribute :use_instantiated_fixtures, default: false # true, false, or :no_instances
+      class_attribute :pre_loaded_fixtures, default: false
+      class_attribute :lock_threads, default: true
+    end
+
+    module ClassMethods
+      # Sets the model class for a fixture when the class name cannot be inferred from the fixture name.
+      #
+      # Examples:
+      #
+      #   set_fixture_class some_fixture:        SomeModel,
+      #                     'namespaced/fixture' => Another::Model
+      #
+      # The keys must be the fixture names, that coincide with the short paths to the fixture files.
+      def set_fixture_class(class_names = {})
+        self.fixture_class_names = fixture_class_names.merge(class_names.stringify_keys)
+      end
+
+      def fixtures(*fixture_set_names)
+        if fixture_set_names.first == :all
+          raise StandardError, "No fixture path found. Please set `#{self}.fixture_path`." if fixture_path.blank?
+          fixture_set_names = Dir[::File.join(fixture_path, "{**,*}/*.{yml}")].uniq
+          fixture_set_names.reject! { |f| f.start_with?(file_fixture_path.to_s) } if defined?(file_fixture_path) && file_fixture_path
+          fixture_set_names.map! { |f| f[fixture_path.to_s.size..-5].delete_prefix("/") }
+        else
+          fixture_set_names = fixture_set_names.flatten.map(&:to_s)
+        end
+
+        self.fixture_table_names |= fixture_set_names
+        setup_fixture_accessors(fixture_set_names)
+      end
+
+      def setup_fixture_accessors(fixture_set_names = nil)
+        fixture_set_names = Array(fixture_set_names || fixture_table_names)
+        methods = Module.new do
+          fixture_set_names.each do |fs_name|
+            fs_name = fs_name.to_s
+            accessor_name = fs_name.tr("/", "_").to_sym
+
+            define_method(accessor_name) do |*fixture_names|
+              force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload
+              return_single_record = fixture_names.size == 1
+              fixture_names = @loaded_fixtures[fs_name].fixtures.keys if fixture_names.empty?
+
+              @fixture_cache[fs_name] ||= {}
+
+              instances = fixture_names.map do |f_name|
+                f_name = f_name.to_s if f_name.is_a?(Symbol)
+                @fixture_cache[fs_name].delete(f_name) if force_reload
+
+                if @loaded_fixtures[fs_name][f_name]
+                  @fixture_cache[fs_name][f_name] ||= @loaded_fixtures[fs_name][f_name].find
+                else
+                  raise StandardError, "No fixture named '#{f_name}' found for fixture set '#{fs_name}'"
+                end
+              end
+
+              return_single_record ? instances.first : instances
+            end
+            private accessor_name
+          end
+        end
+        include methods
+      end
+
+      def uses_transaction(*methods)
+        @uses_transaction = [] unless defined?(@uses_transaction)
+        @uses_transaction.concat methods.map(&:to_s)
+      end
+
+      def uses_transaction?(method)
+        @uses_transaction = [] unless defined?(@uses_transaction)
+        @uses_transaction.include?(method.to_s)
+      end
+    end
+
+    def run_in_transaction?
+      use_transactional_tests &&
+        !self.class.uses_transaction?(name)
+    end
+
+    def setup_fixtures(config = ActiveRecord::Base)
+      if pre_loaded_fixtures && !use_transactional_tests
+        raise RuntimeError, "pre_loaded_fixtures requires use_transactional_tests"
+      end
+
+      @fixture_cache = {}
+      @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?
+        if @@already_loaded_fixtures[self.class]
+          @loaded_fixtures = @@already_loaded_fixtures[self.class]
+        else
+          @loaded_fixtures = load_fixtures(config)
+          @@already_loaded_fixtures[self.class] = @loaded_fixtures
+        end
+
+        # Begin transactions for connections already established
+        @fixture_connections = enlist_fixture_connections
+        @fixture_connections.each do |connection|
+          connection.begin_transaction joinable: false, _lazy: false
+          connection.pool.lock_thread = true if lock_threads
+        end
+
+        # When connections are established in the future, begin a transaction too
+        @connection_subscriber = ActiveSupport::Notifications.subscribe("!connection.active_record") do |_, _, _, _, payload|
+          spec_name = payload[:spec_name] if payload.key?(:spec_name)
+          shard = payload[:shard] if payload.key?(:shard)
+          setup_shared_connection_pool if ActiveRecord::Base.legacy_connection_handling
+
+          if spec_name
+            begin
+              connection = ActiveRecord::Base.connection_handler.retrieve_connection(spec_name, shard: shard)
+            rescue ConnectionNotEstablished
+              connection = nil
+            end
+
+            if connection
+              setup_shared_connection_pool unless ActiveRecord::Base.legacy_connection_handling
+
+              if !@fixture_connections.include?(connection)
+                connection.begin_transaction joinable: false, _lazy: false
+                connection.pool.lock_thread = true if lock_threads
+                @fixture_connections << connection
+              end
+            end
+          end
+        end
+
+      # Load fixtures for every test.
+      else
+        ActiveRecord::FixtureSet.reset_cache
+        @@already_loaded_fixtures[self.class] = nil
+        @loaded_fixtures = load_fixtures(config)
+      end
+
+      # Instantiate fixtures for every test if requested.
+      instantiate_fixtures if use_instantiated_fixtures
+    end
+
+    def teardown_fixtures
+      # Rollback changes if a transaction is active.
+      if run_in_transaction?
+        ActiveSupport::Notifications.unsubscribe(@connection_subscriber) if @connection_subscriber
+        @fixture_connections.each do |connection|
+          connection.rollback_transaction if connection.transaction_open?
+          connection.pool.lock_thread = false
+        end
+        @fixture_connections.clear
+        teardown_shared_connection_pool
+      else
+        ActiveRecord::FixtureSet.reset_cache
+      end
+
+      ActiveRecord::Base.clear_active_connections!
+    end
+
+    def enlist_fixture_connections
+      setup_shared_connection_pool
+
+      ActiveRecord::Base.connection_handler.connection_pool_list.map(&:connection)
+    end
+
+    private
+      # Shares the writing connection pool with connections on
+      # other handlers.
+      #
+      # In an application with a primary and replica the test fixtures
+      # 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]
+
+          ActiveRecord::Base.connection_handlers.values.each do |handler|
+            if handler != writing_handler
+              handler.connection_pool_names.each do |name|
+                writing_pool_manager = writing_handler.send(:owner_to_pool_manager)[name]
+                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
+            end
+          end
+        else
+          handler = ActiveRecord::Base.connection_handler
+
+          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)
+              @saved_pool_configs[name][shard_name] ||= {}
+              pool_manager.role_names.each do |role|
+                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
+          end
+        end
+      end
+
+      def teardown_shared_connection_pool
+        if ActiveRecord::Base.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
+
+      def instantiate_fixtures
+        if pre_loaded_fixtures
+          raise RuntimeError, "Load fixtures before instantiating them." if ActiveRecord::FixtureSet.all_loaded_fixtures.empty?
+          ActiveRecord::FixtureSet.instantiate_all_loaded_fixtures(self, load_instances?)
+        else
+          raise RuntimeError, "Load fixtures before instantiating them." if @loaded_fixtures.nil?
+          @loaded_fixtures.each_value do |fixture_set|
+            ActiveRecord::FixtureSet.instantiate_fixtures(self, fixture_set, load_instances?)
+          end
+        end
+      end
+
+      def load_instances?
+        use_instantiated_fixtures != :no_instances
+      end
+  end
+end

data/lib/active_record/timestamp.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module ActiveRecord
-  # = Active Record Timestamp
+  # = Active Record \Timestamp
   #
   # Active Record automatically timestamps create and update operations if the
   # table has fields named <tt>created_at/created_on</tt> or
@@ -15,14 +17,25 @@ module ActiveRecord
   #
   # == Time Zone aware attributes
   #
-  # By default, ActiveRecord::Base keeps all the datetime columns time zone aware by executing following code.
+  # Active Record keeps all the <tt>datetime</tt> and <tt>time</tt> columns
+  # timezone aware. By default, these values are stored in the database as UTC
+  # and converted back to the current <tt>Time.zone</tt> when pulled from the database.
+  #
+  # This feature can be turned off completely by setting:
+  #
+  #   config.active_record.time_zone_aware_attributes = false
+  #
+  # You can also specify that only <tt>datetime</tt> columns should be time-zone
+  # aware (while <tt>time</tt> should not) by setting:
+  #
+  #   ActiveRecord::Base.time_zone_aware_types = [:datetime]
   #
-  #   config.active_record.time_zone_aware_attributes = true
+  # You can also add database specific timezone aware types. For example, for PostgreSQL:
   #
-  # This feature can easily be turned off by assigning value <tt>false</tt> .
+  #   ActiveRecord::Base.time_zone_aware_types += [:tsrange, :tstzrange]
   #
-  # If your attributes are time zone aware and you desire to skip time zone conversion to the current Time.zone
-  # when reading certain attributes then you can do following:
+  # Finally, you can indicate specific attributes of a model for which time zone
+  # conversion should not applied, for instance by setting:
   #
   #   class Topic < ActiveRecord::Base
   #     self.skip_time_zone_conversion_for_attributes = [:written_on]
@@ -31,8 +44,7 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :record_timestamps
-      self.record_timestamps = true
+      class_attribute :record_timestamps, default: true
     end
 
     def initialize_dup(other) # :nodoc:
@@ -40,81 +52,112 @@ module ActiveRecord
       clear_timestamp_attributes
     end
 
-  private
+    module ClassMethods # :nodoc:
+      def touch_attributes_with_time(*names, time: nil)
+        attribute_names = timestamp_attributes_for_update_in_model
+        attribute_names |= names.map(&:to_s)
+        attribute_names.index_with(time || current_time_from_proper_timezone)
+      end
+
+      def timestamp_attributes_for_create_in_model
+        @timestamp_attributes_for_create_in_model ||=
+          (timestamp_attributes_for_create & column_names).freeze
+      end
 
+      def timestamp_attributes_for_update_in_model
+        @timestamp_attributes_for_update_in_model ||=
+          (timestamp_attributes_for_update & column_names).freeze
+      end
+
+      def all_timestamp_attributes_in_model
+        @all_timestamp_attributes_in_model ||=
+          (timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model).freeze
+      end
+
+      def current_time_from_proper_timezone
+        default_timezone == :utc ? Time.now.utc : Time.now
+      end
+
+      private
+        def timestamp_attributes_for_create
+          ["created_at", "created_on"].map! { |name| attribute_aliases[name] || name }
+        end
+
+        def timestamp_attributes_for_update
+          ["updated_at", "updated_on"].map! { |name| attribute_aliases[name] || name }
+        end
+
+        def reload_schema_from_cache
+          @timestamp_attributes_for_create_in_model = nil
+          @timestamp_attributes_for_update_in_model = nil
+          @all_timestamp_attributes_in_model = nil
+          super
+        end
+    end
+
+  private
     def _create_record
-      if self.record_timestamps
+      if record_timestamps
         current_time = current_time_from_proper_timezone
 
-        all_timestamp_attributes.each do |column|
-          column = column.to_s
-          if has_attribute?(column) && !attribute_present?(column)
-            write_attribute(column, current_time)
-          end
+        all_timestamp_attributes_in_model.each do |column|
+          _write_attribute(column, current_time) unless _read_attribute(column)
         end
       end
 
       super
     end
 
-    def _update_record(*args)
-      if should_record_timestamps?
+    def _update_record
+      if @_touch_record && should_record_timestamps?
         current_time = current_time_from_proper_timezone
 
         timestamp_attributes_for_update_in_model.each do |column|
-          column = column.to_s
-          next if attribute_changed?(column)
-          write_attribute(column, current_time)
+          next if will_save_change_to_attribute?(column)
+          _write_attribute(column, current_time)
         end
       end
+
+      super
+    end
+
+    def create_or_update(touch: true, **)
+      @_touch_record = touch
       super
     end
 
     def should_record_timestamps?
-      self.record_timestamps && (!partial_writes? || changed?)
+      record_timestamps && (!partial_writes? || has_changes_to_save?)
     end
 
     def timestamp_attributes_for_create_in_model
-      timestamp_attributes_for_create.select { |c| self.class.column_names.include?(c.to_s) }
+      self.class.timestamp_attributes_for_create_in_model
     end
 
     def timestamp_attributes_for_update_in_model
-      timestamp_attributes_for_update.select { |c| self.class.column_names.include?(c.to_s) }
+      self.class.timestamp_attributes_for_update_in_model
     end
 
     def all_timestamp_attributes_in_model
-      timestamp_attributes_for_create_in_model + timestamp_attributes_for_update_in_model
+      self.class.all_timestamp_attributes_in_model
     end
 
-    def timestamp_attributes_for_update
-      [:updated_at, :updated_on]
-    end
-
-    def timestamp_attributes_for_create
-      [:created_at, :created_on]
-    end
-
-    def all_timestamp_attributes
-      timestamp_attributes_for_create + timestamp_attributes_for_update
+    def current_time_from_proper_timezone
+      self.class.current_time_from_proper_timezone
     end
 
-    def max_updated_column_timestamp(timestamp_names = timestamp_attributes_for_update)
-      timestamp_names
-        .map { |attr| self[attr] }
+    def max_updated_column_timestamp
+      timestamp_attributes_for_update_in_model
+        .map { |attr| self[attr]&.to_time }
         .compact
-        .map(&:to_time)
         .max
     end
 
-    def current_time_from_proper_timezone
-      self.class.default_timezone == :utc ? Time.now.utc : Time.now
-    end
-
     # Clear attributes and changed_attributes
     def clear_timestamp_attributes
       all_timestamp_attributes_in_model.each do |attribute_name|
         self[attribute_name] = nil
-        clear_attribute_changes([attribute_name])
+        clear_attribute_change(attribute_name)
       end
     end
   end

data/lib/active_record/touch_later.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  # = Active Record Touch Later
+  module TouchLater # :nodoc:
+    def before_committed!
+      touch_deferred_attributes if has_defer_touch_attrs? && persisted?
+      super
+    end
+
+    def touch_later(*names) # :nodoc:
+      _raise_record_not_touched_error unless persisted?
+
+      @_defer_touch_attrs ||= timestamp_attributes_for_update_in_model
+      @_defer_touch_attrs |= names.map! do |name|
+        name = name.to_s
+        self.class.attribute_aliases[name] || name
+      end unless names.empty?
+
+      @_touch_time = current_time_from_proper_timezone
+
+      surreptitiously_touch @_defer_touch_attrs
+      add_to_transaction
+      @_new_record_before_last_commit ||= false
+
+      # touch the parents as we are not calling the after_save callbacks
+      self.class.reflect_on_all_associations(:belongs_to).each do |r|
+        if touch = r.options[:touch]
+          ActiveRecord::Associations::Builder::BelongsTo.touch_record(self, changes_to_save, r.foreign_key, r.name, touch, :touch_later)
+        end
+      end
+    end
+
+    def touch(*names, time: nil) # :nodoc:
+      if has_defer_touch_attrs?
+        names |= @_defer_touch_attrs
+        super(*names, time: time)
+        @_defer_touch_attrs, @_touch_time = nil, nil
+      else
+        super
+      end
+    end
+
+    private
+      def surreptitiously_touch(attr_names)
+        attr_names.each do |attr_name|
+          _write_attribute(attr_name, @_touch_time)
+          clear_attribute_change(attr_name)
+        end
+      end
+
+      def touch_deferred_attributes
+        @_skip_dirty_tracking = true
+        touch(time: @_touch_time)
+      end
+
+      def has_defer_touch_attrs?
+        defined?(@_defer_touch_attrs) && @_defer_touch_attrs.present?
+      end
+
+      def belongs_to_touch_method
+        :touch_later
+      end
+  end
+end