activerecord 7.1.1 → 7.1.5

data/lib/active_record/nested_attributes.rb

@@ -307,7 +307,7 @@ module ActiveRecord
       # [:allow_destroy]
       #   If true, destroys any members from the attributes hash with a
       #   <tt>_destroy</tt> key and a value that evaluates to +true+
-      #   (e.g. 1, '1', true, or 'true'). This option is off by default.
+      #   (e.g. 1, '1', true, or 'true'). This option is false by default.
       # [:reject_if]
       #   Allows you to specify a Proc or a Symbol pointing to a method
       #   that checks whether a record should be built for a certain attribute
@@ -332,11 +332,11 @@ module ActiveRecord
       #   nested attributes are going to be used when an associated record already
       #   exists. In general, an existing record may either be updated with the
       #   new set of attribute values or be replaced by a wholly new record
-      #   containing those values. By default the +:update_only+ option is +false+
+      #   containing those values. By default the +:update_only+ option is false
       #   and the nested attributes are used to update the existing record only
       #   if they include the record's <tt>:id</tt> value. Otherwise a new
       #   record will be instantiated and used to replace the existing one.
-      #   However if the +:update_only+ option is +true+, the nested attributes
+      #   However if the +:update_only+ option is true, the nested attributes
       #   are used to update the record's attributes always, regardless of
       #   whether the <tt>:id</tt> is present. The option is ignored for collection
       #   associations.
@@ -519,12 +519,12 @@ module ActiveRecord
             unless reject_new_record?(association_name, attributes)
               association.reader.build(attributes.except(*UNASSIGNABLE_KEYS))
             end
-          elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes["id"].to_s }
+          elsif existing_record = find_record_by_id(existing_records, attributes["id"])
             unless call_reject_if(association_name, attributes)
               # Make sure we are operating on the actual object which is in the association's
               # proxy_target array (either by finding it, or adding it if not found)
               # Take into account that the proxy_target may have changed due to callbacks
-              target_record = association.target.detect { |record| record.id.to_s == attributes["id"].to_s }
+              target_record = find_record_by_id(association.target, attributes["id"])
               if target_record
                 existing_record = target_record
               else
@@ -612,5 +612,16 @@ module ActiveRecord
         raise RecordNotFound.new("Couldn't find #{model} with ID=#{record_id} for #{self.class.name} with ID=#{id}",
                                  model, "id", record_id)
       end
+
+      def find_record_by_id(records, id)
+        return if records.empty?
+
+        if records.first.class.composite_primary_key?
+          id = Array(id).map(&:to_s)
+          records.find { |record| Array(record.id).map(&:to_s) == id }
+        else
+          records.find { |record| record.id.to_s == id.to_s }
+        end
+      end
   end
 end

data/lib/active_record/normalization.rb

@@ -49,6 +49,14 @@ module ActiveRecord # :nodoc:
       # By default, the normalization will not be applied to +nil+ values. This
       # behavior can be changed with the +:apply_to_nil+ option.
       #
+      # Be aware that if your app was created before Rails 7.1, and your app
+      # marshals instances of the targeted model (for example, when caching),
+      # then you should set ActiveRecord.marshalling_format_version to +7.1+ or
+      # higher via either <tt>config.load_defaults 7.1</tt> or
+      # <tt>config.active_record.marshalling_format_version = 7.1</tt>.
+      # Otherwise, +Marshal+ may attempt to serialize the normalization +Proc+
+      # and raise +TypeError+.
+      #
       # ==== Options
       #
       # * +:with+ - Any callable object that accepts the attribute's value as

data/lib/active_record/persistence.rb

@@ -115,7 +115,7 @@ module ActiveRecord
       # ==== Options
       #
       # [:returning]
-      #   (PostgreSQL only) An array of attributes to return for all successfully
+      #   (PostgreSQL and SQLite3 only) An array of attributes to return for all successfully
       #   inserted records, which by default is the primary key.
       #   Pass <tt>returning: %w[ id name ]</tt> for both id and name
       #   or <tt>returning: false</tt> to omit the underlying <tt>RETURNING</tt> SQL
@@ -205,7 +205,7 @@ module ActiveRecord
       # ==== Options
       #
       # [:returning]
-      #   (PostgreSQL only) An array of attributes to return for all successfully
+      #   (PostgreSQL and SQLite3 only) An array of attributes to return for all successfully
       #   inserted records, which by default is the primary key.
       #   Pass <tt>returning: %w[ id name ]</tt> for both id and name
       #   or <tt>returning: false</tt> to omit the underlying <tt>RETURNING</tt> SQL
@@ -271,7 +271,7 @@ module ActiveRecord
       # ==== Options
       #
       # [:returning]
-      #   (PostgreSQL only) An array of attributes to return for all successfully
+      #   (PostgreSQL and SQLite3 only) An array of attributes to return for all successfully
       #   inserted records, which by default is the primary key.
       #   Pass <tt>returning: %w[ id name ]</tt> for both id and name
       #   or <tt>returning: false</tt> to omit the underlying <tt>RETURNING</tt> SQL
@@ -456,7 +456,7 @@ module ActiveRecord
       end
 
       # Accepts a list of attribute names to be used in the WHERE clause
-      # of SELECT / UPDATE / DELETE queries and in the ORDER BY clause for `#first` and `#last` finder methods.
+      # of SELECT / UPDATE / DELETE queries and in the ORDER BY clause for +#first+ and +#last+ finder methods.
       #
       #   class Developer < ActiveRecord::Base
       #     query_constraints :company_id, :id
@@ -469,7 +469,7 @@ module ActiveRecord
       #   developer.update!(name: "Nikita")
       #   # UPDATE "developers" SET "name" = 'Nikita' WHERE "developers"."company_id" = 1 AND "developers"."id" = 1
       #
-      #   It is possible to update attribute used in the query_by clause:
+      #   # It is possible to update an attribute used in the query_constraints clause:
       #   developer.update!(company_id: 2)
       #   # UPDATE "developers" SET "company_id" = 2 WHERE "developers"."company_id" = 1 AND "developers"."id" = 1
       #
@@ -1076,6 +1076,7 @@ module ActiveRecord
       end
 
       @association_cache = fresh_object.instance_variable_get(:@association_cache)
+      @association_cache.each_value { |association| association.owner = self }
       @attributes = fresh_object.instance_variable_get(:@attributes)
       @new_record = false
       @previously_new_record = false

data/lib/active_record/promise.rb

@@ -31,7 +31,7 @@ module ActiveRecord
     # Returns a new +ActiveRecord::Promise+ that will apply the passed block
     # when the value is accessed:
     #
-    #   Post.async_pluck(:title).then { |title| title.upcase }.value
+    #   Post.async_pick(:title).then { |title| title.upcase }.value
     #   # => "POST TITLE"
     def then(&block)
       Promise.new(@future_result, @block ? @block >> block : block)

data/lib/active_record/query_cache.rb

@@ -30,7 +30,7 @@ module ActiveRecord
     end
 
     def self.complete(pools)
-      pools.each { |pool| pool.disable_query_cache! }
+      pools.each { |pool| pool.disable_query_cache! unless pool.discarded? }
 
       ActiveRecord::Base.connection_handler.each_connection_pool do |pool|
         pool.release_connection if pool.active_connection? && !pool.connection.transaction_open?

data/lib/active_record/query_logs_formatter.rb

@@ -28,7 +28,7 @@ module ActiveRecord
       end
 
       def format(pairs)
-        pairs.sort_by!(&:first)
+        pairs.sort_by! { |pair| pair.first.to_s }
         super
       end
 

data/lib/active_record/railtie.rb

@@ -146,6 +146,7 @@ To keep using the current cache store, you can turn off cache versioning entirel
         config.after_initialize do |app|
           ActiveSupport.on_load(:active_record) do
             db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).first
+            next if db_config.nil?
 
             filename = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(
               db_config.name,
@@ -261,8 +262,7 @@ To keep using the current cache store, you can turn off cache versioning entirel
       end
 
       ActiveSupport.on_load(:active_record) do
-        # Configs used in other initializers
-        configs = configs.except(
+        configs_used_in_other_initializers = configs.except(
           :migration_error,
           :database_selector,
           :database_resolver,
@@ -279,7 +279,7 @@ To keep using the current cache store, you can turn off cache versioning entirel
           :use_schema_cache_dump
         )
 
-        configs.each do |k, v|
+        configs_used_in_other_initializers.each do |k, v|
           next if k == :encryption
           setter = "#{k}="
           # Some existing initializers might rely on Active Record configuration
@@ -377,23 +377,23 @@ To keep using the current cache store, you can turn off cache versioning entirel
     end
 
     initializer "active_record_encryption.configuration" do |app|
-      auto_filtered_parameters = ActiveRecord::Encryption::AutoFilteredParameters.new(app)
-
-      config.after_initialize do |app|
-        ActiveRecord::Encryption.configure \
+      ActiveSupport.on_load(:active_record_encryption) do
+        ActiveRecord::Encryption.configure(
           primary_key: app.credentials.dig(:active_record_encryption, :primary_key),
           deterministic_key: app.credentials.dig(:active_record_encryption, :deterministic_key),
           key_derivation_salt: app.credentials.dig(:active_record_encryption, :key_derivation_salt),
-          **config.active_record.encryption
+          **app.config.active_record.encryption
+        )
 
+        auto_filtered_parameters = ActiveRecord::Encryption::AutoFilteredParameters.new(app)
         auto_filtered_parameters.enable if ActiveRecord::Encryption.config.add_to_filter_parameters
+      end
 
-        ActiveSupport.on_load(:active_record) do
-          # Support extended queries for deterministic attributes and validations
-          if ActiveRecord::Encryption.config.extend_queries
-            ActiveRecord::Encryption::ExtendedDeterministicQueries.install_support
-            ActiveRecord::Encryption::ExtendedDeterministicUniquenessValidator.install_support
-          end
+      ActiveSupport.on_load(:active_record) do
+        # Support extended queries for deterministic attributes and validations
+        if ActiveRecord::Encryption.config.extend_queries
+          ActiveRecord::Encryption::ExtendedDeterministicQueries.install_support
+          ActiveRecord::Encryption::ExtendedDeterministicUniquenessValidator.install_support
         end
       end
 

data/lib/active_record/railties/controller_runtime.rb

@@ -37,9 +37,10 @@ module ActiveRecord
             db_rt_before_render = ActiveRecord::RuntimeRegistry.reset
             self.db_runtime = (db_runtime || 0) + db_rt_before_render
             runtime = super
+            queries_rt = ActiveRecord::RuntimeRegistry.sql_runtime - ActiveRecord::RuntimeRegistry.async_sql_runtime
             db_rt_after_render = ActiveRecord::RuntimeRegistry.reset
             self.db_runtime += db_rt_after_render
-            runtime - db_rt_after_render
+            runtime - queries_rt
           else
             super
           end

data/lib/active_record/railties/databases.rake

@@ -89,10 +89,10 @@ db_namespace = namespace :db do
   task migrate: :load_config do
     db_configs = ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env)
 
-    if db_configs.size == 1
+    if db_configs.size == 1 && db_configs.first.primary?
       ActiveRecord::Tasks::DatabaseTasks.migrate
     else
-      mapped_versions = ActiveRecord::Tasks::DatabaseTasks.db_configs_with_versions(db_configs)
+      mapped_versions = ActiveRecord::Tasks::DatabaseTasks.db_configs_with_versions
 
       mapped_versions.sort.each do |version, db_configs|
         db_configs.each do |db_config|
@@ -195,7 +195,7 @@ db_namespace = namespace :db do
 
     namespace :up do
       ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
-        desc 'Run the "up" on #{name} database for a given migration VERSION.'
+        desc "Run the \"up\" on #{name} database for a given migration VERSION."
         task name => :load_config do
           raise "VERSION is required" if !ENV["VERSION"] || ENV["VERSION"].empty?
 
@@ -204,7 +204,7 @@ db_namespace = namespace :db do
             conn.migration_context.run(:up, ActiveRecord::Tasks::DatabaseTasks.target_version)
           end
 
-          db_namespace["_dump"].invoke
+          db_namespace["_dump:#{name}"].invoke
         end
       end
     end
@@ -226,7 +226,7 @@ db_namespace = namespace :db do
 
     namespace :down do
       ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
-        desc 'Run the "down" on #{name} database for a given migration VERSION.'
+        desc "Run the \"down\" on #{name} database for a given migration VERSION."
         task name => :load_config do
           raise "VERSION is required" if !ENV["VERSION"] || ENV["VERSION"].empty?
 
@@ -235,7 +235,7 @@ db_namespace = namespace :db do
             conn.migration_context.run(:down, ActiveRecord::Tasks::DatabaseTasks.target_version)
           end
 
-          db_namespace["_dump"].invoke
+          db_namespace["_dump:#{name}"].invoke
         end
       end
     end
@@ -269,7 +269,7 @@ db_namespace = namespace :db do
           conn.migration_context.rollback(step)
         end
 
-        db_namespace["_dump"].invoke
+        db_namespace["_dump:#{name}"].invoke
       end
     end
   end

data/lib/active_record/reflection.rb

@@ -382,6 +382,7 @@ module ActiveRecord
         @klass         = options[:anonymous_class]
         @plural_name   = active_record.pluralize_table_names ?
                             name.to_s.pluralize : name.to_s
+        validate_reflection!
       end
 
       def autosave=(autosave)
@@ -433,6 +434,17 @@ module ActiveRecord
         def derive_class_name
           name.to_s.camelize
         end
+
+        def validate_reflection!
+          return unless options[:foreign_key].is_a?(Array)
+
+          message = <<~MSG.squish
+            Passing #{options[:foreign_key]} array to :foreign_key option
+            on the #{active_record}##{name} association is not supported.
+            Use the query_constraints: #{options[:foreign_key]} option instead to represent a composite foreign key.
+          MSG
+          raise ArgumentError, message
+        end
     end
 
     # Holds all the metadata about an aggregation as it was specified in the
@@ -774,7 +786,7 @@ module ActiveRecord
           primary_query_constraints = active_record.query_constraints_list
           owner_pk = active_record.primary_key
 
-          if primary_query_constraints.size != 2
+          if primary_query_constraints.size > 2
             raise ArgumentError, <<~MSG.squish
               The query constraints list on the `#{active_record}` model has more than 2
               attributes. Active Record is unable to derive the query constraints
@@ -792,6 +804,8 @@ module ActiveRecord
             MSG
           end
 
+          return foreign_key if primary_query_constraints.include?(foreign_key)
+
           first_key, last_key = primary_query_constraints
 
           if first_key == owner_pk
@@ -857,8 +871,12 @@ module ActiveRecord
       # klass option is necessary to support loading polymorphic associations
       def association_primary_key(klass = nil)
         if primary_key = options[:primary_key]
-          @association_primary_key ||= -primary_key.to_s
-        elsif !polymorphic? && ((klass || self.klass).has_query_constraints? || options[:query_constraints])
+          @association_primary_key ||= if primary_key.is_a?(Array)
+            primary_key.map { |pk| pk.to_s.freeze }.freeze
+          else
+            -primary_key.to_s
+          end
+        elsif (klass || self.klass).has_query_constraints? || options[:query_constraints]
           (klass || self.klass).composite_query_constraints_list
         elsif (klass || self.klass).composite_primary_key?
           # If klass has composite primary key of shape [:<tenant_key>, :id], infer primary_key as :id

data/lib/active_record/relation/calculations.rb

@@ -81,6 +81,16 @@ module ActiveRecord
     #
     # Note: not all valid {Relation#select}[rdoc-ref:QueryMethods#select] expressions are valid #count expressions. The specifics differ
     # between databases. In invalid cases, an error from the database is thrown.
+    #
+    # When given a block, loads all records in the relation, if the relation
+    # hasn't been loaded yet. Calls the block with each record in the relation.
+    # Returns the number of records for which the block returns a truthy value.
+    #
+    #   Person.count { |person| person.age > 21 }
+    #   # => counts the number of people older that 21
+    #
+    # Note: If there are a lot of records in the relation, loading all records
+    # could result in performance issues.
     def count(column_name = nil)
       if block_given?
         unless column_name.nil?
@@ -148,6 +158,17 @@ module ActiveRecord
     # #calculate for examples with options.
     #
     #   Person.sum(:age) # => 4562
+    #
+    # When given a block, loads all records in the relation, if the relation
+    # hasn't been loaded yet. Calls the block with each record in the relation.
+    # Returns the sum of +initial_value_or_column+ and the block return
+    # values:
+    #
+    #   Person.sum { |person| person.age } # => 4562
+    #   Person.sum(1000) { |person| person.age } # => 5562
+    #
+    # Note: If there are a lot of records in the relation, loading all records
+    # could result in performance issues.
     def sum(initial_value_or_column = 0, &block)
       if block_given?
         map(&block).sum(initial_value_or_column)
@@ -260,7 +281,13 @@ module ActiveRecord
     #
     # See also #ids.
     def pluck(*column_names)
-      return [] if @none
+      if @none
+        if @async
+          return Promise::Complete.new([])
+        else
+          return []
+        end
+      end
 
       if loaded? && all_attributes?(column_names)
         result = records.pluck(*column_names)

data/lib/active_record/relation/delegation.rb

@@ -102,7 +102,7 @@ module ActiveRecord
              :to_sentence, :to_fs, :to_formatted_s, :as_json,
              :shuffle, :split, :slice, :index, :rindex, to: :records
 
-    delegate :primary_key, :connection, to: :klass
+    delegate :primary_key, :connection, :transaction, to: :klass
 
     module ClassSpecificRelation # :nodoc:
       extend ActiveSupport::Concern

data/lib/active_record/relation/predicate_builder/polymorphic_array_value.rb

@@ -43,7 +43,12 @@ module ActiveRecord
 
         def convert_to_id(value)
           if value.is_a?(Base)
-            value._read_attribute(primary_key(value))
+            primary_key = primary_key(value)
+            if primary_key.is_a?(Array)
+              primary_key.map { |column| value._read_attribute(column) }
+            else
+              value._read_attribute(primary_key)
+            end
           elsif value.is_a?(Relation)
             value.select(primary_key(value))
           else

data/lib/active_record/relation/query_methods.rb

@@ -1909,18 +1909,32 @@ module ActiveRecord
       end
 
       def column_references(order_args)
-        references = order_args.flat_map do |arg|
+        order_args.flat_map do |arg|
           case arg
           when String, Symbol
-            arg
+            extract_table_name_from(arg)
           when Hash
-            arg.keys.map do |key|
-              key if key.is_a?(String) || key.is_a?(Symbol)
+            arg
+              .map do |key, value|
+                case value
+                when Hash
+                  key.to_s
+                else
+                  extract_table_name_from(key) if key.is_a?(String) || key.is_a?(Symbol)
+                end
+              end
+          when Arel::Attribute
+            arg.relation.name
+          when Arel::Nodes::Ordering
+            if arg.expr.is_a?(Arel::Attribute)
+              arg.expr.relation.name
             end
           end
-        end
-        references.map! { |arg| arg =~ /^\W?(\w+)\W?\./ && $1 }.compact!
-        references
+        end.compact
+      end
+
+      def extract_table_name_from(string)
+        string.match(/^\W?(\w+)\W?\./) && $1
       end
 
       def order_column(field)

data/lib/active_record/relation.rb

@@ -164,8 +164,8 @@ module ActiveRecord
     #
     # If creation failed because of a unique constraint, this method will
     # assume it encountered a race condition and will try finding the record
-    # once more If somehow the second find still find no record because a
-    # concurrent DELETE happened, it will then raise an
+    # once more. If somehow the second find still does not find a record
+    # because a concurrent DELETE happened, it will then raise an
     # ActiveRecord::RecordNotFound exception.
     #
     # Please note <b>this method is not atomic</b>, it runs first a SELECT,
@@ -291,6 +291,11 @@ module ActiveRecord
     end
 
     # Returns true if there are no records.
+    #
+    # When a pattern argument is given, this method checks whether elements in
+    # the Enumerable match the pattern via the case-equality operator (<tt>===</tt>).
+    #
+    #   posts.none?(Comment) # => true or false
     def none?(*args)
       return true if @none
 
@@ -299,6 +304,11 @@ module ActiveRecord
     end
 
     # Returns true if there are any records.
+    #
+    # When a pattern argument is given, this method checks whether elements in
+    # the Enumerable match the pattern via the case-equality operator (<tt>===</tt>).
+    #
+    #    posts.any?(Post) # => true or false
     def any?(*args)
       return false if @none
 
@@ -307,6 +317,11 @@ module ActiveRecord
     end
 
     # Returns true if there is exactly one record.
+    #
+    # When a pattern argument is given, this method checks whether elements in
+    # the Enumerable match the pattern via the case-equality operator (<tt>===</tt>).
+    #
+    #    posts.one?(Post) # => true or false
     def one?(*args)
       return false if @none
 
@@ -511,7 +526,12 @@ module ActiveRecord
 
       group_values_arel_columns = arel_columns(group_values.uniq)
       having_clause_ast = having_clause.ast unless having_clause.empty?
-      stmt = arel.compile_update(values, table[primary_key], having_clause_ast, group_values_arel_columns)
+      key = if klass.composite_primary_key?
+        primary_key.map { |pk| table[pk] }
+      else
+        table[primary_key]
+      end
+      stmt = arel.compile_update(values, key, having_clause_ast, group_values_arel_columns)
       klass.connection.update(stmt, "#{klass} Update All").tap { reset }
     end
 
@@ -644,7 +664,12 @@ module ActiveRecord
 
       group_values_arel_columns = arel_columns(group_values.uniq)
       having_clause_ast = having_clause.ast unless having_clause.empty?
-      stmt = arel.compile_delete(table[primary_key], having_clause_ast, group_values_arel_columns)
+      key = if klass.composite_primary_key?
+        primary_key.map { |pk| table[pk] }
+      else
+        table[primary_key]
+      end
+      stmt = arel.compile_delete(key, having_clause_ast, group_values_arel_columns)
 
       klass.connection.delete(stmt, "#{klass} Delete All").tap { reset }
     end
@@ -960,7 +985,7 @@ module ActiveRecord
       def exec_main_query(async: false)
         if @none
           if async
-            return Promise::Complete.new([])
+            return FutureResult.wrap([])
           else
             return []
           end

data/lib/active_record/result.rb

@@ -195,7 +195,7 @@ module ActiveRecord
       EMPTY = new([].freeze, [].freeze, {}.freeze).freeze
       private_constant :EMPTY
 
-      EMPTY_ASYNC = FutureResult::Complete.new(EMPTY).freeze
+      EMPTY_ASYNC = FutureResult.wrap(EMPTY).freeze
       private_constant :EMPTY_ASYNC
   end
 end

data/lib/active_record/runtime_registry.rb

@@ -17,13 +17,27 @@ module ActiveRecord
       ActiveSupport::IsolatedExecutionState[:active_record_sql_runtime] = runtime
     end
 
+    def async_sql_runtime
+      ActiveSupport::IsolatedExecutionState[:active_record_async_sql_runtime] ||= 0.0
+    end
+
+    def async_sql_runtime=(runtime)
+      ActiveSupport::IsolatedExecutionState[:active_record_async_sql_runtime] = runtime
+    end
+
     def reset
       rt, self.sql_runtime = sql_runtime, 0.0
+      self.async_sql_runtime = 0.0
       rt
     end
   end
 end
 
 ActiveSupport::Notifications.monotonic_subscribe("sql.active_record") do |name, start, finish, id, payload|
-  ActiveRecord::RuntimeRegistry.sql_runtime += (finish - start) * 1_000.0
+  runtime = (finish - start) * 1_000.0
+
+  if payload[:async]
+    ActiveRecord::RuntimeRegistry.async_sql_runtime += (runtime - payload[:lock_wait])
+  end
+  ActiveRecord::RuntimeRegistry.sql_runtime += runtime
 end

data/lib/active_record/schema_migration.rb

@@ -6,7 +6,7 @@ module ActiveRecord
   # number is inserted in to the schema migrations table so it doesn't need
   # to be executed the next time.
   class SchemaMigration # :nodoc:
-    class NullSchemaMigration
+    class NullSchemaMigration # :nodoc:
     end
 
     attr_reader :connection, :arel_table

data/lib/active_record/secure_token.rb

@@ -53,7 +53,7 @@ module ActiveRecord
         define_method("regenerate_#{attribute}") { update! attribute => self.class.generate_unique_secure_token(length: length) }
         set_callback on, on == :initialize ? :after : :before do
           if new_record? && !query_attribute(attribute)
-            write_attribute(attribute, self.class.generate_unique_secure_token(length: length))
+            send("#{attribute}=", self.class.generate_unique_secure_token(length: length))
           end
         end
       end