activerecord 6.1.4.6 → 7.0.2.3

data/lib/active_record/encryption.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module"
+require "active_support/core_ext/array"
+
+module ActiveRecord
+  module Encryption
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Cipher
+      autoload :Config
+      autoload :Configurable
+      autoload :Context
+      autoload :Contexts
+      autoload :DerivedSecretKeyProvider
+      autoload :EncryptableRecord
+      autoload :EncryptedAttributeType
+      autoload :EncryptedFixtures
+      autoload :EncryptingOnlyEncryptor
+      autoload :DeterministicKeyProvider
+      autoload :Encryptor
+      autoload :EnvelopeEncryptionKeyProvider
+      autoload :Errors
+      autoload :ExtendedDeterministicQueries
+      autoload :ExtendedDeterministicUniquenessValidator
+      autoload :Key
+      autoload :KeyGenerator
+      autoload :KeyProvider
+      autoload :Message
+      autoload :MessageSerializer
+      autoload :NullEncryptor
+      autoload :Properties
+      autoload :ReadOnlyNullEncryptor
+      autoload :Scheme
+    end
+
+    class Cipher
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :Aes256Gcm
+      end
+    end
+
+    include Configurable
+    include Contexts
+
+    def self.eager_load!
+      super
+
+      Cipher.eager_load!
+    end
+  end
+end

data/lib/active_record/enum.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/hash/slice"
 require "active_support/core_ext/object/deep_dup"
 
 module ActiveRecord
@@ -7,7 +8,7 @@ module ActiveRecord
   # but can be queried by name. Example:
   #
   #   class Conversation < ActiveRecord::Base
-  #     enum status: [ :active, :archived ]
+  #     enum :status, [ :active, :archived ]
   #   end
   #
   #   # conversation.update! status: 0
@@ -41,26 +42,33 @@ module ActiveRecord
   #   Conversation.where(status: [:active, :archived])
   #   Conversation.where.not(status: :active)
   #
-  # Defining scopes can be disabled by setting +:_scopes+ to +false+.
+  # Defining scopes can be disabled by setting +:scopes+ to +false+.
   #
   #   class Conversation < ActiveRecord::Base
-  #     enum status: [ :active, :archived ], _scopes: false
+  #     enum :status, [ :active, :archived ], scopes: false
   #   end
   #
-  # You can set the default enum value by setting +:_default+, like:
+  # You can set the default enum value by setting +:default+, like:
   #
   #   class Conversation < ActiveRecord::Base
-  #     enum status: [ :active, :archived ], _default: "active"
+  #     enum :status, [ :active, :archived ], default: :active
   #   end
   #
   #   conversation = Conversation.new
   #   conversation.status # => "active"
   #
-  # Finally, it's also possible to explicitly map the relation between attribute and
+  # It's possible to explicitly map the relation between attribute and
   # database integer with a hash:
   #
   #   class Conversation < ActiveRecord::Base
-  #     enum status: { active: 0, archived: 1 }
+  #     enum :status, active: 0, archived: 1
+  #   end
+  #
+  # Finally it's also possible to use a string column to persist the enumerated value.
+  # Note that this will likely lead to slower database queries:
+  #
+  #   class Conversation < ActiveRecord::Base
+  #     enum :status, active: "active", archived: "archived"
   #   end
   #
   # Note that when an array is used, the implicit mapping from the values to database
@@ -85,14 +93,14 @@ module ActiveRecord
   #
   #   Conversation.where("status <> ?", Conversation.statuses[:archived])
   #
-  # You can use the +:_prefix+ or +:_suffix+ options when you need to define
+  # You can use the +:prefix+ or +:suffix+ options when you need to define
   # multiple enums with same values. If the passed value is +true+, the methods
   # are prefixed/suffixed with the name of the enum. It is also possible to
   # supply a custom value:
   #
   #   class Conversation < ActiveRecord::Base
-  #     enum status: [:active, :archived], _suffix: true
-  #     enum comments_status: [:active, :inactive], _prefix: :comments
+  #     enum :status, [ :active, :archived ], suffix: true
+  #     enum :comments_status, [ :active, :inactive ], prefix: :comments
   #   end
   #
   # With the above example, the bang and predicate methods along with the
@@ -103,7 +111,6 @@ module ActiveRecord
   #
   #   conversation.comments_inactive!
   #   conversation.comments_active? # => false
-
   module Enum
     def self.extended(base) # :nodoc:
       base.class_attribute(:defined_enums, instance_writer: false, default: {})
@@ -128,10 +135,8 @@ module ActiveRecord
           value.to_s
         elsif mapping.has_value?(value)
           mapping.key(value)
-        elsif value.blank?
-          nil
         else
-          assert_valid_value(value)
+          value.presence
         end
       end
 
@@ -140,7 +145,11 @@ module ActiveRecord
       end
 
       def serialize(value)
-        mapping.fetch(value, value)
+        subtype.serialize(mapping.fetch(value, value))
+      end
+
+      def serializable?(value, &block)
+        subtype.serializable?(mapping.fetch(value, value), &block)
       end
 
       def assert_valid_value(value)
@@ -155,15 +164,20 @@ module ActiveRecord
         attr_reader :name, :mapping
     end
 
-    def enum(definitions)
-      enum_prefix = definitions.delete(:_prefix)
-      enum_suffix = definitions.delete(:_suffix)
-      enum_scopes = definitions.delete(:_scopes)
+    def enum(name = nil, values = nil, **options)
+      if name
+        values, options = options, {} unless values
+        return _enum(name, values, **options)
+      end
+
+      definitions = options.slice!(:_prefix, :_suffix, :_scopes, :_default)
+      options.transform_keys! { |key| :"#{key[1..-1]}" }
 
-      default = {}
-      default[:default] = definitions.delete(:_default) if definitions.key?(:_default)
+      definitions.each { |name, values| _enum(name, values, **options) }
+    end
 
-      definitions.each do |name, values|
+    private
+      def _enum(name, values, prefix: nil, suffix: nil, scopes: true, **options)
         assert_valid_enum_definition_values(values)
         # statuses = { }
         enum_values = ActiveSupport::HashWithIndifferentAccess.new
@@ -177,24 +191,19 @@ module ActiveRecord
         detect_enum_conflict!(name, name)
         detect_enum_conflict!(name, "#{name}=")
 
-        attr = attribute_alias?(name) ? attribute_alias(name) : name
-
-        decorate_attribute_type(attr, **default) do |subtype|
-          EnumType.new(attr, enum_values, subtype)
+        attribute(name, **options) do |subtype|
+          subtype = subtype.subtype if EnumType === subtype
+          EnumType.new(name, enum_values, subtype)
         end
 
         value_method_names = []
         _enum_methods_module.module_eval do
-          prefix = if enum_prefix == true
-            "#{name}_"
-          elsif enum_prefix
-            "#{enum_prefix}_"
+          prefix = if prefix
+            prefix == true ? "#{name}_" : "#{prefix}_"
           end
 
-          suffix = if enum_suffix == true
-            "_#{name}"
-          elsif enum_suffix
-            "_#{enum_suffix}"
+          suffix = if suffix
+            suffix == true ? "_#{name}" : "_#{suffix}"
           end
 
           pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
@@ -204,23 +213,21 @@ module ActiveRecord
 
             value_method_name = "#{prefix}#{label}#{suffix}"
             value_method_names << value_method_name
-            define_enum_methods(name, value_method_name, value, enum_scopes)
+            define_enum_methods(name, value_method_name, value, scopes)
 
             method_friendly_label = label.gsub(/[\W&&[:ascii:]]+/, "_")
             value_method_alias = "#{prefix}#{method_friendly_label}#{suffix}"
 
             if value_method_alias != value_method_name && !value_method_names.include?(value_method_alias)
               value_method_names << value_method_alias
-              define_enum_methods(name, value_method_alias, value, enum_scopes)
+              define_enum_methods(name, value_method_alias, value, scopes)
             end
           end
         end
-        detect_negative_enum_conditions!(value_method_names) if enum_scopes != false
+        detect_negative_enum_conditions!(value_method_names) if scopes
         enum_values.freeze
       end
-    end
 
-    private
       class EnumMethods < Module # :nodoc:
         def initialize(klass)
           @klass = klass
@@ -229,7 +236,7 @@ module ActiveRecord
         private
           attr_reader :klass
 
-          def define_enum_methods(name, value_method_name, value, enum_scopes)
+          def define_enum_methods(name, value_method_name, value, scopes)
             # def active?() status_for_database == 0 end
             klass.send(:detect_enum_conflict!, name, "#{value_method_name}?")
             define_method("#{value_method_name}?") { public_send(:"#{name}_for_database") == value }
@@ -240,7 +247,7 @@ module ActiveRecord
 
             # scope :active, -> { where(status: 0) }
             # scope :not_active, -> { where.not(status: 0) }
-            if enum_scopes != false
+            if scopes
               klass.send(:detect_enum_conflict!, name, value_method_name, true)
               klass.scope value_method_name, -> { where(name => value) }
 
@@ -260,7 +267,7 @@ module ActiveRecord
       end
 
       def assert_valid_enum_definition_values(values)
-        unless values.is_a?(Hash) || values.all? { |v| v.is_a?(Symbol) } || values.all? { |v| v.is_a?(String) }
+        unless values.is_a?(Hash) || values.all?(Symbol) || values.all?(String)
           error_message = <<~MSG
             Enum values #{values} must be either a hash, an array of symbols, or an array of strings.
           MSG

data/lib/active_record/errors.rb

@@ -63,6 +63,30 @@ module ActiveRecord
   class ConnectionTimeoutError < ConnectionNotEstablished
   end
 
+  # Raised when connection to the database could not been established because it was not
+  # able to connect to the host or when the authorization failed.
+  class DatabaseConnectionError < ConnectionNotEstablished
+    def initialize(message = nil)
+      super(message || "Database connection error")
+    end
+
+    class << self
+      def hostname_error(hostname)
+        DatabaseConnectionError.new(<<~MSG)
+          There is an issue connecting with your hostname: #{hostname}.\n
+          Please check your database configuration and ensure there is a valid connection to your database.
+        MSG
+      end
+
+      def username_error(username)
+        DatabaseConnectionError.new(<<~MSG)
+          There is an issue connecting to your database with your username/password, username: #{username}.\n
+          Please check your database configuration to ensure the username/password are valid.
+        MSG
+      end
+    end
+  end
+
   # Raised when a pool was unable to get ahold of all its connections
   # to perform a "group" action such as
   # {ActiveRecord::Base.connection_pool.disconnect!}[rdoc-ref:ConnectionAdapters::ConnectionPool#disconnect!]
@@ -100,7 +124,7 @@ module ActiveRecord
   end
 
   # Raised by {ActiveRecord::Base#destroy!}[rdoc-ref:Persistence#destroy!]
-  # when a call to {#destroy}[rdoc-ref:Persistence#destroy!]
+  # when a call to {#destroy}[rdoc-ref:Persistence#destroy]
   # would return false.
   #
   #   begin
@@ -118,6 +142,16 @@ module ActiveRecord
     end
   end
 
+  # Raised when Active Record finds multiple records but only expected one.
+  class SoleRecordExceeded < ActiveRecordError
+    attr_reader :record
+
+    def initialize(record = nil)
+      @record = record
+      super "Wanted only one #{record&.name || "record"}"
+    end
+  end
+
   # Superclass for all database execution errors.
   #
   # Wraps the underlying database error as +cause+.
@@ -202,6 +236,30 @@ module ActiveRecord
 
   # Raised when a given database does not exist.
   class NoDatabaseError < StatementInvalid
+    include ActiveSupport::ActionableError
+
+    action "Create database" do
+      ActiveRecord::Tasks::DatabaseTasks.create_current
+    end
+
+    def initialize(message = nil)
+      super(message || "Database not found")
+    end
+
+    class << self
+      def db_error(db_name)
+        NoDatabaseError.new(<<~MSG)
+          We could not find your database: #{db_name}. Which can be found in the database configuration file located at config/database.yml.
+
+          To resolve this issue:
+
+          - Did you create the database for this app, or delete it? You may need to create your database.
+          - Has the database name changed? Check your database.yml config has the correct database name.
+
+          To create your database, run:\n\n        bin/rails db:create
+        MSG
+      end
+    end
   end
 
   # Raised when creating a database if it exists.
@@ -268,7 +326,7 @@ module ActiveRecord
   #           # The system must fail on Friday so that our support department
   #           # won't be out of job. We silently rollback this transaction
   #           # without telling the user.
-  #           raise ActiveRecord::Rollback, "Call tech support!"
+  #           raise ActiveRecord::Rollback
   #         end
   #       end
   #       # ActiveRecord::Rollback is the only exception that won't be passed on
@@ -363,6 +421,11 @@ module ActiveRecord
   class TransactionRollbackError < StatementInvalid
   end
 
+  # AsynchronousQueryInsideTransactionError will be raised when attempting
+  # to perform an asynchronous query from inside a transaction
+  class AsynchronousQueryInsideTransactionError < ActiveRecordError
+  end
+
   # SerializationFailure will be raised when a transaction is rolled
   # back by the database due to a serialization failure.
   class SerializationFailure < TransactionRollbackError
@@ -409,12 +472,12 @@ module ActiveRecord
   #
   # For example, the following code would raise this exception:
   #
-  #   Post.order("length(title)").first
+  #   Post.order("REPLACE(title, 'misc', 'zzzz') asc").pluck(:id)
   #
   # The desired result can be accomplished by wrapping the known-safe string
   # in Arel.sql:
   #
-  #   Post.order(Arel.sql("length(title)")).first
+  #   Post.order(Arel.sql("REPLACE(title, 'misc', 'zzzz') asc")).pluck(:id)
   #
   # Again, such a workaround should *not* be used when passing user-provided
   # values, such as request parameters or model attributes to query methods.

data/lib/active_record/explain_registry.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "active_support/per_thread_registry"
+require "active_support/core_ext/module/delegation"
 
 module ActiveRecord
   # This is a thread locals registry for EXPLAIN. For example
@@ -8,13 +8,18 @@ module ActiveRecord
   #   ActiveRecord::ExplainRegistry.queries
   #
   # returns the collected queries local to the current thread.
-  #
-  # See the documentation of ActiveSupport::PerThreadRegistry
-  # for further details.
   class ExplainRegistry # :nodoc:
-    extend ActiveSupport::PerThreadRegistry
+    class << self
+      delegate :reset, :collect, :collect=, :collect?, :queries, to: :instance
+
+      private
+        def instance
+          ActiveSupport::IsolatedExecutionState[:active_record_explain_registry] ||= new
+        end
+    end
 
-    attr_accessor :queries, :collect
+    attr_accessor :collect
+    attr_reader :queries
 
     def initialize
       reset

data/lib/active_record/fixture_set/file.rb

@@ -41,7 +41,7 @@ module ActiveRecord
           @config_row ||= begin
             row = raw_rows.find { |fixture_name, _| fixture_name == "_fixture" }
             if row
-              row.last
+              validate_config_row(row.last)
             else
               { 'model_class': nil, 'ignore': nil }
             end
@@ -58,6 +58,20 @@ module ActiveRecord
           end
         end
 
+        def validate_config_row(data)
+          unless Hash === data
+            raise Fixture::FormatError, "Invalid `_fixture` section: `_fixture` must be a hash: #{@file}"
+          end
+
+          begin
+            data.assert_valid_keys("model_class", "ignore")
+          rescue ArgumentError => error
+            raise Fixture::FormatError, "Invalid `_fixture` section: #{error.message}: #{@file}"
+          end
+
+          data
+        end
+
         # Validate our unmarshalled data.
         def validate(data)
           unless Hash === data || YAML::Omap === data

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
@@ -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 has_many :through
   #
   # 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