activerecord 6.1.7.8 → 7.0.8.4

data/lib/active_record/fixture_set/table_row.rb

@@ -33,6 +33,33 @@ module ActiveRecord
         def join_table
           @association.through_reflection.table_name
         end
+
+        def timestamp_column_names
+          @association.through_reflection.klass.all_timestamp_attributes_in_model
+        end
+      end
+
+      class PrimaryKeyError < StandardError # :nodoc:
+        def initialize(label, association, value)
+          super(<<~MSG)
+            Unable to set #{association.name} to #{value} because the association has a
+            custom primary key (#{association.join_primary_key}) that does not match the
+            associated table's primary key (#{association.klass.primary_key}).
+
+            To fix this, change your fixture from
+
+            #{label}:
+              #{association.name}: #{value}
+
+            to
+
+            #{label}:
+              #{association.foreign_key}: **value**
+
+            where **value** is the #{association.join_primary_key} value for the
+            associated #{association.klass.name} record.
+          MSG
+        end
       end
 
       def initialize(fixture, table_rows:, label:, now:)
@@ -99,7 +126,7 @@ module ActiveRecord
         end
 
         def resolve_enums
-          model_class.defined_enums.each do |name, values|
+          reflection_class.defined_enums.each do |name, values|
             if @row.include?(name)
               @row[name] = values.fetch(@row[name], @row[name])
             end
@@ -115,9 +142,13 @@ module ActiveRecord
               fk_name = association.join_foreign_key
 
               if association.name.to_s != fk_name && value = @row.delete(association.name.to_s)
-                if association.polymorphic? && value.sub!(/\s*\(([^\)]*)\)\s*$/, "")
-                  # support polymorphic belongs_to as "label (Type)"
-                  @row[association.join_foreign_type] = $1
+                if association.polymorphic?
+                  if value.sub!(/\s*\(([^)]*)\)\s*$/, "")
+                    # support polymorphic belongs_to as "label (Type)"
+                    @row[association.join_foreign_type] = $1
+                  end
+                elsif association.join_primary_key != association.klass.primary_key
+                  raise PrimaryKeyError.new(@label, association, value)
                 end
 
                 fk_type = reflection_class.type_for_attribute(fk_name).type
@@ -141,8 +172,12 @@ module ActiveRecord
 
             targets = targets.is_a?(Array) ? targets : targets.split(/\s*,\s*/)
             joins   = targets.map do |target|
-              { lhs_key => @row[model_metadata.primary_key_name],
-                rhs_key => ActiveRecord::FixtureSet.identify(target, column_type) }
+              join = { lhs_key => @row[model_metadata.primary_key_name],
+                       rhs_key => ActiveRecord::FixtureSet.identify(target, column_type) }
+              association.timestamp_column_names.each do |col|
+                join[col] = @now
+              end
+              join
             end
             @table_rows.tables[table_name].concat(joins)
           end

data/lib/active_record/fixture_set/table_rows.rb

@@ -6,7 +6,7 @@ require "active_record/fixture_set/model_metadata"
 module ActiveRecord
   class FixtureSet
     class TableRows # :nodoc:
-      def initialize(table_name, model_class:, fixtures:, config:)
+      def initialize(table_name, model_class:, fixtures:)
         @model_class = model_class
 
         # track any join tables we need to insert later
@@ -15,7 +15,7 @@ module ActiveRecord
         # ensure this table is loaded before any HABTM associations
         @tables[table_name] = nil
 
-        build_table_rows_from(table_name, fixtures, config)
+        build_table_rows_from(table_name, fixtures)
       end
 
       attr_reader :tables, :model_class
@@ -29,8 +29,8 @@ module ActiveRecord
       end
 
       private
-        def build_table_rows_from(table_name, fixtures, config)
-          now = config.default_timezone == :utc ? Time.now.utc : Time.now
+        def build_table_rows_from(table_name, fixtures)
+          now = ActiveRecord.default_timezone == :utc ? Time.now.utc : Time.now
 
           @tables[table_name] = fixtures.map do |label, fixture|
             TableRow.new(

data/lib/active_record/fixtures.rb

@@ -12,7 +12,7 @@ require "active_record/fixture_set/table_rows"
 require "active_record/test_fixtures"
 
 module ActiveRecord
-  class FixtureClassNotFound < ActiveRecord::ActiveRecordError #:nodoc:
+  class FixtureClassNotFound < ActiveRecord::ActiveRecordError # :nodoc:
   end
 
   # \Fixtures are a way of organizing data that you want to test against; in short, sample data.
@@ -35,7 +35,7 @@ module ActiveRecord
   #     name: Google
   #     url: http://www.google.com
   #
-  # This fixture file includes two fixtures. Each YAML fixture (ie. record) is given a name and
+  # This fixture file includes two fixtures. Each YAML fixture (i.e. record) is given a name and
   # is followed by an indented list of key/value pairs in the "key: value" format. Records are
   # separated by a blank line for your viewing pleasure.
   #
@@ -152,7 +152,7 @@ module ActiveRecord
   # - define a helper method in <tt>test_helper.rb</tt>
   #     module FixtureFileHelpers
   #       def file_sha(path)
-  #         Digest::SHA2.hexdigest(File.read(Rails.root.join('test/fixtures', path)))
+  #         OpenSSL::Digest::SHA256.hexdigest(File.read(Rails.root.join('test/fixtures', path)))
   #       end
   #     end
   #     ActiveRecord::FixtureSet.context_class.include FixtureFileHelpers
@@ -241,13 +241,13 @@ module ActiveRecord
   # The generated ID for a given label is constant, so we can discover
   # any fixture's ID without loading anything, as long as we know the label.
   #
-  # == Label references for associations (belongs_to, has_one, has_many)
+  # == Label references for associations (+belongs_to+, +has_one+, +has_many+)
   #
   # Specifying foreign keys in fixtures can be very fragile, not to
   # mention difficult to read. Since Active Record can figure out the ID of
   # any fixture from its label, you can specify FK's by label instead of ID.
   #
-  # === belongs_to
+  # === +belongs_to+
   #
   # Let's break out some more monkeys and pirates.
   #
@@ -286,7 +286,7 @@ module ActiveRecord
   # a target *label* for the *association* (monkey: george) rather than
   # a target *id* for the *FK* (<tt>monkey_id: 1</tt>).
   #
-  # ==== Polymorphic belongs_to
+  # ==== Polymorphic +belongs_to+
   #
   # Supporting polymorphic relationships is a little bit more complicated, since
   # Active Record needs to know what type your association is pointing at. Something
@@ -311,7 +311,7 @@ module ActiveRecord
   #
   # Just provide the polymorphic target type and Active Record will take care of the rest.
   #
-  # === has_and_belongs_to_many
+  # === +has_and_belongs_to_many+ or <tt>has_many :through</tt>
   #
   # Time to give our monkey some fruit.
   #
@@ -407,7 +407,7 @@ module ActiveRecord
   # defaults:
   #
   #   DEFAULTS: &DEFAULTS
-  #     created_on: <%= 3.weeks.ago.to_s(:db) %>
+  #     created_on: <%= 3.weeks.ago.to_fs(:db) %>
   #
   #   first:
   #     name: Smurf
@@ -426,7 +426,7 @@ module ActiveRecord
   #   _fixture:
   #     ignore:
   #       - base
-  #     # or use "ignore: base" when there is only one fixture needs to be ignored.
+  #     # or use "ignore: base" when there is only one fixture that needs to be ignored.
   #
   #   base: &base
   #     admin: false
@@ -585,14 +585,6 @@ module ActiveRecord
         end
       end
 
-      def signed_global_id(fixture_set_name, label, column_type: :integer, **options)
-        identifier = identify(label, column_type)
-        model_name = default_fixture_model_name(fixture_set_name)
-        uri = URI::GID.build([GlobalID.app, model_name, identifier, {}])
-
-        SignedGlobalID.new(uri, **options)
-      end
-
       # Superclass for the evaluation contexts used by ERB fixtures.
       def context_class
         @context_class ||= Class.new
@@ -637,6 +629,10 @@ module ActiveRecord
 
             conn.insert_fixtures_set(table_rows_for_connection, table_rows_for_connection.keys)
 
+            if ActiveRecord.verify_foreign_keys_for_fixtures && !conn.all_foreign_keys_valid?
+              raise "Foreign key violations found in your fixture data. Ensure you aren't referring to labels that don't exist on associations."
+            end
+
             # Cap primary key sequences to max(pk).
             if conn.respond_to?(:reset_pk_sequence!)
               set.each { |fs| conn.reset_pk_sequence!(fs.table_name) }
@@ -689,7 +685,6 @@ module ActiveRecord
         table_name,
         model_class: model_class,
         fixtures: fixtures,
-        config: config,
       ).to_hash
     end
 
@@ -741,13 +736,13 @@ module ActiveRecord
       end
   end
 
-  class Fixture #:nodoc:
+  class Fixture # :nodoc:
     include Enumerable
 
-    class FixtureError < StandardError #:nodoc:
+    class FixtureError < StandardError # :nodoc:
     end
 
-    class FormatError < FixtureError #:nodoc:
+    class FormatError < FixtureError # :nodoc:
     end
 
     attr_reader :model_class, :fixture
@@ -761,8 +756,8 @@ module ActiveRecord
       model_class.name if model_class
     end
 
-    def each
-      fixture.each { |item| yield item }
+    def each(&block)
+      fixture.each(&block)
     end
 
     def [](key)
@@ -782,3 +777,5 @@ module ActiveRecord
     end
   end
 end
+
+ActiveSupport.run_load_hooks :active_record_fixture_set, ActiveRecord::FixtureSet

data/lib/active_record/future_result.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class FutureResult # :nodoc:
+    class EventBuffer
+      def initialize(future_result, instrumenter)
+        @future_result = future_result
+        @instrumenter = instrumenter
+        @events = []
+      end
+
+      def instrument(name, payload = {}, &block)
+        event = @instrumenter.new_event(name, payload)
+        @events << event
+        event.record(&block)
+      end
+
+      def flush
+        events, @events = @events, []
+        events.each do |event|
+          event.payload[:lock_wait] = @future_result.lock_wait
+          ActiveSupport::Notifications.publish_event(event)
+        end
+      end
+    end
+
+    Canceled = Class.new(ActiveRecordError)
+
+    delegate :empty?, :to_a, to: :result
+
+    attr_reader :lock_wait
+
+    def initialize(pool, *args, **kwargs)
+      @mutex = Mutex.new
+
+      @session = nil
+      @pool = pool
+      @args = args
+      @kwargs = kwargs
+
+      @pending = true
+      @error = nil
+      @result = nil
+      @instrumenter = ActiveSupport::Notifications.instrumenter
+      @event_buffer = nil
+    end
+
+    def schedule!(session)
+      @session = session
+      @pool.schedule_query(self)
+    end
+
+    def execute!(connection)
+      execute_query(connection)
+    end
+
+    def cancel
+      @pending = false
+      @error = Canceled
+      self
+    end
+
+    def execute_or_skip
+      return unless pending?
+
+      @pool.with_connection do |connection|
+        return unless @mutex.try_lock
+        begin
+          if pending?
+            @event_buffer = EventBuffer.new(self, @instrumenter)
+            connection.with_instrumenter(@event_buffer) do
+              execute_query(connection, async: true)
+            end
+          end
+        ensure
+          @mutex.unlock
+        end
+      end
+    end
+
+    def result
+      execute_or_wait
+      @event_buffer&.flush
+
+      if canceled?
+        raise Canceled
+      elsif @error
+        raise @error
+      else
+        @result
+      end
+    end
+
+    def pending?
+      @pending && (!@session || @session.active?)
+    end
+
+    private
+      def canceled?
+        @session && !@session.active?
+      end
+
+      def execute_or_wait
+        if pending?
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+          @mutex.synchronize do
+            if pending?
+              execute_query(@pool.connection)
+            else
+              @lock_wait = (Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start)
+            end
+          end
+        else
+          @lock_wait = 0.0
+        end
+      end
+
+      def execute_query(connection, async: false)
+        @result = exec_query(connection, *@args, **@kwargs, async: async)
+      rescue => error
+        @error = error
+      ensure
+        @pending = false
+      end
+
+      def exec_query(connection, *args, **kwargs)
+        connection.exec_query(*args, **kwargs)
+      end
+
+      class SelectAll < FutureResult # :nodoc:
+        private
+          def exec_query(*, **)
+            super
+          rescue ::RangeError
+            ActiveRecord::Result.empty
+          end
+      end
+  end
+end

data/lib/active_record/gem_version.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 module ActiveRecord
-  # Returns the version of the currently loaded Active Record as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of Active Record as a <tt>Gem::Version</tt>.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 6
-    MINOR = 1
-    TINY  = 7
-    PRE   = "8"
+    MAJOR = 7
+    MINOR = 0
+    TINY  = 8
+    PRE   = "4"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/inheritance.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_support/inflector"
 require "active_support/core_ext/hash/indifferent_access"
 
 module ActiveRecord
@@ -43,6 +44,8 @@ module ActiveRecord
       # Determines whether to store the full constant name including namespace when using STI.
       # This is true, by default.
       class_attribute :store_full_sti_class, instance_writer: false, default: true
+
+      set_base_class
     end
 
     module ClassMethods
@@ -85,7 +88,7 @@ module ActiveRecord
         end
       end
 
-      def finder_needs_type_condition? #:nodoc:
+      def finder_needs_type_condition? # :nodoc:
         # This is like this because benchmarking justifies the strange :false stuff
         :true == (@finder_needs_type_condition ||= descends_from_active_record? ? :false : :true)
       end
@@ -98,17 +101,7 @@ module ActiveRecord
       #
       # If B < A and C < B and if A is an abstract_class then both B.base_class
       # and C.base_class would return B as the answer since A is an abstract_class.
-      def base_class
-        unless self < Base
-          raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
-        end
-
-        if superclass == Base || superclass.abstract_class?
-          self
-        else
-          superclass.base_class
-        end
-      end
+      attr_reader :base_class
 
       # Returns whether the class is a base class.
       # See #base_class for more information.
@@ -164,6 +157,21 @@ module ActiveRecord
         defined?(@abstract_class) && @abstract_class == true
       end
 
+      # Sets the application record class for Active Record
+      #
+      # This is useful if your application uses a different class than
+      # ApplicationRecord for your primary abstract class. This class
+      # will share a database connection with Active Record. It is the class
+      # that connects to your primary database.
+      def primary_abstract_class
+        if ActiveRecord.application_record_class && ActiveRecord.application_record_class.name != name
+          raise ArgumentError, "The `primary_abstract_class` is already set to #{ActiveRecord.application_record_class.inspect}. There can only be one `primary_abstract_class` in an application."
+        end
+
+        self.abstract_class = true
+        ActiveRecord.application_record_class = self
+      end
+
       # Returns the value to be stored in the inheritance column for STI.
       def sti_name
         store_full_sti_class && store_full_class_name ? name : name.demodulize
@@ -174,7 +182,7 @@ module ActiveRecord
       # It is used to find the class correspondent to the value stored in the inheritance column.
       def sti_class_for(type_name)
         if store_full_sti_class && store_full_class_name
-          ActiveSupport::Dependencies.constantize(type_name)
+          type_name.constantize
         else
           compute_type(type_name)
         end
@@ -196,17 +204,31 @@ module ActiveRecord
       # It is used to find the class correspondent to the value stored in the polymorphic type column.
       def polymorphic_class_for(name)
         if store_full_class_name
-          ActiveSupport::Dependencies.constantize(name)
+          name.constantize
         else
           compute_type(name)
         end
       end
 
       def inherited(subclass)
+        subclass.set_base_class
         subclass.instance_variable_set(:@_type_candidates_cache, Concurrent::Map.new)
         super
       end
 
+      def dup # :nodoc:
+        # `initialize_dup` / `initialize_copy` don't work when defined
+        # in the `singleton_class`.
+        other = super
+        other.set_base_class
+        other
+      end
+
+      def initialize_clone(other) # :nodoc:
+        super
+        set_base_class
+      end
+
       protected
         # Returns the class type of the record using the current module as a prefix. So descendants of
         # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
@@ -214,10 +236,10 @@ module ActiveRecord
           if type_name.start_with?("::")
             # If the type is prefixed with a scope operator then we assume that
             # the type_name is an absolute reference.
-            ActiveSupport::Dependencies.constantize(type_name)
+            type_name.constantize
           else
             type_candidate = @_type_candidates_cache[type_name]
-            if type_candidate && type_constant = ActiveSupport::Dependencies.safe_constantize(type_candidate)
+            if type_candidate && type_constant = type_candidate.safe_constantize
               return type_constant
             end
 
@@ -227,7 +249,7 @@ module ActiveRecord
             candidates << type_name
 
             candidates.each do |candidate|
-              constant = ActiveSupport::Dependencies.safe_constantize(candidate)
+              constant = candidate.safe_constantize
               if candidate == constant.to_s
                 @_type_candidates_cache[type_name] = candidate
                 return constant
@@ -238,6 +260,22 @@ module ActiveRecord
           end
         end
 
+        def set_base_class # :nodoc:
+          @base_class = if self == Base
+            self
+          else
+            unless self < Base
+              raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
+            end
+
+            if superclass == Base || superclass.abstract_class?
+              self
+            else
+              superclass.base_class
+            end
+          end
+        end
+
       private
         # Called by +instantiate+ to decide which class to use for a new
         # record instance. For single-table inheritance, we check the record