activerecord 7.2.1.1 → 8.0.0.rc1

data/lib/active_record/encryption/key_provider.rb

@@ -12,7 +12,7 @@ module ActiveRecord
         @keys = Array(keys)
       end
 
-      # Returns the first key in the list as the active key to perform encryptions
+      # Returns the last key in the list as the active key to perform encryptions
       #
       # When +ActiveRecord::Encryption.config.store_key_references+ is true, the key will include
       # a public tag referencing the key itself. That key will be stored in the public

data/lib/active_record/encryption/scheme.rb

@@ -11,7 +11,7 @@ module ActiveRecord
       attr_accessor :previous_schemes
 
       def initialize(key_provider: nil, key: nil, deterministic: nil, support_unencrypted_data: nil, downcase: nil, ignore_case: nil,
-                     previous_schemes: nil, **context_properties)
+                     previous_schemes: nil, compress: true, compressor: nil, **context_properties)
         # Initializing all attributes to +nil+ as we want to allow a "not set" semantics so that we
         # can merge schemes without overriding values with defaults. See +#merge+
 
@@ -24,8 +24,13 @@ module ActiveRecord
         @previous_schemes_param = previous_schemes
         @previous_schemes = Array.wrap(previous_schemes)
         @context_properties = context_properties
+        @compress = compress
+        @compressor = compressor
 
         validate_config!
+
+        @context_properties[:encryptor] = Encryptor.new(compress: @compress) unless @compress
+        @context_properties[:encryptor] = Encryptor.new(compressor: compressor) if compressor
       end
 
       def ignore_case?
@@ -78,6 +83,8 @@ module ActiveRecord
         def validate_config!
           raise Errors::Configuration, "ignore_case: can only be used with deterministic encryption" if @ignore_case && !@deterministic
           raise Errors::Configuration, "key_provider: and key: can't be used simultaneously" if @key_provider_param && @key
+          raise Errors::Configuration, "compressor: can't be used with compress: false" if !@compress && @compressor
+          raise Errors::Configuration, "compressor: can't be used with encryptor" if @compressor && @context_properties[:encryptor]
         end
 
         def key_provider_from_key

data/lib/active_record/encryption.rb

@@ -53,4 +53,6 @@ module ActiveRecord
       Cipher.eager_load!
     end
   end
+
+  ActiveSupport.run_load_hooks :active_record_encryption, Encryption
 end

data/lib/active_record/enum.rb

@@ -167,15 +167,6 @@ module ActiveRecord
       base.class_attribute(:defined_enums, instance_writer: false, default: {})
     end
 
-    def load_schema! # :nodoc:
-      defined_enums.each_key do |name|
-        unless columns_hash.key?(resolve_attribute_name(name))
-          raise "Unknown enum attribute '#{name}' for #{self.name}. Enums must be" \
-            " backed by a database column."
-        end
-      end
-    end
-
     class EnumType < Type::Value # :nodoc:
       delegate :type, to: :subtype
 
@@ -222,89 +213,77 @@ module ActiveRecord
         attr_reader :name, :mapping
     end
 
-    def enum(name = nil, values = nil, **options)
-      if name
-        values, options = options, {} unless values
-        return _enum(name, values, **options)
-      end
+    def enum(name, values, prefix: nil, suffix: nil, scopes: true, instance_methods: true, validate: false, **options)
+      assert_valid_enum_definition_values(values)
+      assert_valid_enum_options(options)
 
-      definitions = options.slice!(:_prefix, :_suffix, :_scopes, :_default, :_instance_methods)
-      options.transform_keys! { |key| :"#{key[1..-1]}" }
+      # statuses = { }
+      enum_values = ActiveSupport::HashWithIndifferentAccess.new
+      name = name.to_s
 
-      definitions.each { |name, values| _enum(name, values, **options) }
+      # def self.statuses() statuses end
+      detect_enum_conflict!(name, name.pluralize, true)
+      singleton_class.define_method(name.pluralize) { enum_values }
+      defined_enums[name] = enum_values
 
-      ActiveRecord.deprecator.warn(<<~MSG)
-        Defining enums with keyword arguments is deprecated and will be removed
-        in Rails 8.0. Positional arguments should be used instead:
+      detect_enum_conflict!(name, name)
+      detect_enum_conflict!(name, "#{name}=")
 
-        #{definitions.map { |name, values| "enum :#{name}, #{values}" }.join("\n")}
-      MSG
-    end
+      attribute(name, **options)
 
-    private
-      def inherited(base)
-        base.defined_enums = defined_enums.deep_dup
-        super
-      end
-
-      def _enum(name, values, prefix: nil, suffix: nil, scopes: true, instance_methods: true, validate: false, **options)
-        assert_valid_enum_definition_values(values)
-        assert_valid_enum_options(options)
-        # statuses = { }
-        enum_values = ActiveSupport::HashWithIndifferentAccess.new
-        name = name.to_s
-
-        # def self.statuses() statuses end
-        detect_enum_conflict!(name, name.pluralize, true)
-        singleton_class.define_method(name.pluralize) { enum_values }
-        defined_enums[name] = enum_values
-
-        detect_enum_conflict!(name, name)
-        detect_enum_conflict!(name, "#{name}=")
+      decorate_attributes([name]) do |_name, subtype|
+        if subtype == ActiveModel::Type.default_value
+          raise "Undeclared attribute type for enum '#{name}' in #{self.name}. Enums must be" \
+            " backed by a database column or declared with an explicit type" \
+            " via `attribute`."
+        end
 
-        attribute(name, **options)
+        subtype = subtype.subtype if EnumType === subtype
+        EnumType.new(name, enum_values, subtype, raise_on_invalid_values: !validate)
+      end
 
-        decorate_attributes([name]) do |name, subtype|
-          subtype = subtype.subtype if EnumType === subtype
-          EnumType.new(name, enum_values, subtype, raise_on_invalid_values: !validate)
+      value_method_names = []
+      _enum_methods_module.module_eval do
+        prefix = if prefix
+          prefix == true ? "#{name}_" : "#{prefix}_"
         end
 
-        value_method_names = []
-        _enum_methods_module.module_eval do
-          prefix = if prefix
-            prefix == true ? "#{name}_" : "#{prefix}_"
-          end
-
-          suffix = if suffix
-            suffix == true ? "_#{name}" : "_#{suffix}"
-          end
+        suffix = if suffix
+          suffix == true ? "_#{name}" : "_#{suffix}"
+        end
 
-          pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
-          pairs.each do |label, value|
-            enum_values[label] = value
-            label = label.to_s
+        pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
+        pairs.each do |label, value|
+          enum_values[label] = value
+          label = label.to_s
 
-            value_method_name = "#{prefix}#{label}#{suffix}"
-            value_method_names << value_method_name
-            define_enum_methods(name, value_method_name, value, scopes, instance_methods)
+          value_method_name = "#{prefix}#{label}#{suffix}"
+          value_method_names << value_method_name
+          define_enum_methods(name, value_method_name, value, scopes, instance_methods)
 
-            method_friendly_label = label.gsub(/[\W&&[:ascii:]]+/, "_")
-            value_method_alias = "#{prefix}#{method_friendly_label}#{suffix}"
+          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, scopes, instance_methods)
-            end
+          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, scopes, instance_methods)
           end
         end
-        detect_negative_enum_conditions!(value_method_names) if scopes
+      end
+      detect_negative_enum_conditions!(value_method_names) if scopes
 
-        if validate
-          validate = {} unless Hash === validate
-          validates_inclusion_of name, in: enum_values.keys, **validate
-        end
+      if validate
+        validate = {} unless Hash === validate
+        validates_inclusion_of name, in: enum_values.keys, **validate
+      end
+
+      enum_values.freeze
+    end
 
-        enum_values.freeze
+    private
+      def inherited(base)
+        base.defined_enums = defined_enums.deep_dup
+        super
       end
 
       class EnumMethods < Module # :nodoc:

data/lib/active_record/errors.rb

@@ -84,6 +84,19 @@ module ActiveRecord
   class ConnectionTimeoutError < ConnectionNotEstablished
   end
 
+  # Raised when a database connection pool is requested but
+  # has not been defined.
+  class ConnectionNotDefined < ConnectionNotEstablished
+    def initialize(message = nil, connection_name: nil, role: nil, shard: nil)
+      super(message)
+      @connection_name = connection_name
+      @role = role
+      @shard = shard
+    end
+
+    attr_reader :connection_name, :role, :shard
+  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
@@ -484,11 +497,6 @@ module ActiveRecord
   #   relation.limit!(5)              # => ActiveRecord::UnmodifiableRelation
   class UnmodifiableRelation < ActiveRecordError
   end
-  deprecate_constant(
-    :ImmutableRelation,
-    "ActiveRecord::UnmodifiableRelation",
-    deprecator: ActiveRecord.deprecator
-  )
 
   # TransactionIsolationError will be raised under the following conditions:
   #

data/lib/active_record/fixtures.rb

@@ -2,8 +2,6 @@
 
 require "erb"
 require "yaml"
-require "zlib"
-require "set"
 require "active_support/dependencies"
 require "active_support/core_ext/digest/uuid"
 require "active_record/test_fixtures"

data/lib/active_record/future_result.rb

@@ -100,17 +100,21 @@ module ActiveRecord
     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)
+      @session.synchronize do
+        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
-        ensure
-          @mutex.unlock
         end
       end
     end
@@ -163,7 +167,7 @@ module ActiveRecord
       end
 
       def exec_query(connection, *args, **kwargs)
-        connection.internal_exec_query(*args, **kwargs)
+        connection.raw_exec_query(*args, **kwargs)
       end
 
       class SelectAll < FutureResult # :nodoc:

data/lib/active_record/gem_version.rb

@@ -7,10 +7,10 @@ module ActiveRecord
   end
 
   module VERSION
-    MAJOR = 7
-    MINOR = 2
-    TINY  = 1
-    PRE   = "1"
+    MAJOR = 8
+    MINOR = 0
+    TINY  = 0
+    PRE   = "rc1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/insert_all.rb

@@ -240,7 +240,7 @@ module ActiveRecord
 
           values_list = insert_all.map_key_with_value do |key, value|
             next value if Arel::Nodes::SqlLiteral === value
-            connection.with_yaml_fallback(types[key].serialize(value))
+            types[key].serialize(types[key].cast(value))
           end
 
           connection.visitor.compile(Arel::Nodes::ValuesList.new(values_list))

data/lib/active_record/locking/optimistic.rb

@@ -9,7 +9,7 @@ module ActiveRecord
     # it was opened, an ActiveRecord::StaleObjectError exception is thrown if that has occurred
     # and the update is ignored.
     #
-    # Check out +ActiveRecord::Locking::Pessimistic+ for an alternative.
+    # Check out ActiveRecord::Locking::Pessimistic for an alternative.
     #
     # == Usage
     #

data/lib/active_record/log_subscriber.rb

@@ -126,18 +126,12 @@ module ActiveRecord
         end
       end
 
-      if Thread.respond_to?(:each_caller_location)
-        def query_source_location
-          Thread.each_caller_location do |location|
-            frame = backtrace_cleaner.clean_frame(location)
-            return frame if frame
-          end
-          nil
-        end
-      else
-        def query_source_location
-          backtrace_cleaner.clean(caller(1).lazy).first
+      def query_source_location
+        Thread.each_caller_location do |location|
+          frame = backtrace_cleaner.clean_frame(location)
+          return frame if frame
         end
+        nil
       end
 
       def filter(name, value)

data/lib/active_record/marshalling.rb

@@ -25,7 +25,10 @@ module ActiveRecord
         payload = [attributes_for_database, new_record?]
 
         cached_associations = self.class.reflect_on_all_associations.select do |reflection|
-          association_cached?(reflection.name) && association(reflection.name).loaded?
+          if association_cached?(reflection.name)
+            association = association(reflection.name)
+            association.loaded? || association.target.present?
+          end
         end
 
         unless cached_associations.empty?

data/lib/active_record/migration/command_recorder.rb

@@ -22,10 +22,12 @@ module ActiveRecord
     # * change_table_comment (must supply a +:from+ and +:to+ option)
     # * create_enum
     # * create_join_table
+    # * create_virtual_table
     # * create_table
     # * disable_extension
     # * drop_enum (must supply a list of values)
     # * drop_join_table
+    # * drop_virtual_table (must supply options)
     # * drop_table (must supply a block)
     # * enable_extension
     # * remove_column (must supply a type)
@@ -55,6 +57,8 @@ module ActiveRecord
         :add_exclusion_constraint, :remove_exclusion_constraint,
         :add_unique_constraint, :remove_unique_constraint,
         :create_enum, :drop_enum, :rename_enum, :add_enum_value, :rename_enum_value,
+        :create_schema, :drop_schema,
+        :create_virtual_table, :drop_virtual_table
       ]
       include JoinTable
 
@@ -163,7 +167,9 @@ module ActiveRecord
               add_exclusion_constraint: :remove_exclusion_constraint,
               add_unique_constraint: :remove_unique_constraint,
               enable_extension:  :disable_extension,
-              create_enum:       :drop_enum
+              create_enum:       :drop_enum,
+              create_schema:     :drop_schema,
+              create_virtual_table: :drop_virtual_table
             }.each do |cmd, inv|
               [[inv, cmd], [cmd, inv]].uniq.each do |method, inverse|
                 class_eval <<-EOV, __FILE__, __LINE__ + 1
@@ -196,13 +202,18 @@ module ActiveRecord
         end
 
         def invert_drop_table(args, &block)
-          if args.last.is_a?(Hash)
-            args.last.delete(:if_exists)
+          options = args.extract_options!
+          options.delete(:if_exists)
+
+          if args.size > 1
+            raise ActiveRecord::IrreversibleMigration, "To avoid mistakes, drop_table is only reversible if given a single table name."
           end
-          if args.size == 1 && block == nil
+
+          if args.size == 1 && options == {} && block == nil
             raise ActiveRecord::IrreversibleMigration, "To avoid mistakes, drop_table is only reversible if given options or a block (can be empty)."
           end
-          super
+
+          super(args.push(options), &block)
         end
 
         def invert_rename_table(args)
@@ -372,6 +383,12 @@ module ActiveRecord
           [:rename_enum_value, [type_name, from: options[:to], to: options[:from]]]
         end
 
+        def invert_drop_virtual_table(args)
+          _enum, values = args.dup.tap(&:extract_options!)
+          raise ActiveRecord::IrreversibleMigration, "drop_virtual_table is only reversible if given options." unless values
+          super
+        end
+
         def respond_to_missing?(method, _)
           super || delegate.respond_to?(method)
         end

data/lib/active_record/migration/compatibility.rb

@@ -21,7 +21,7 @@ module ActiveRecord
       # New migration functionality that will never be backward compatible should be added directly to `ActiveRecord::Migration`.
       #
       # There are classes for each prior Rails version. Each class descends from the *next* Rails version, so:
-      # 5.2 < 6.0 < 6.1 < 7.0 < 7.1 < 7.2
+      # 5.2 < 6.0 < 6.1 < 7.0 < 7.1 < 7.2 < 8.0
       #
       # If you are introducing new migration functionality that should only apply from Rails 7 onward, then you should
       # find the class that immediately precedes it (6.1), and override the relevant migration methods to undo your changes.
@@ -29,7 +29,10 @@ module ActiveRecord
       # For example, Rails 6 added a default value for the `precision` option on datetime columns. So in this file, the `V5_2`
       # class sets the value of `precision` to `nil` if it's not explicitly provided. This way, the default value will not apply
       # for migrations written for 5.2, but will for migrations written for 6.0.
-      V7_2 = Current
+      V8_0 = Current
+
+      class V7_2 < V8_0
+      end
 
       class V7_1 < V7_2
       end