activerecord 7.0.0 → 7.1.2

data/lib/active_record/token_for.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/json"
+
+module ActiveRecord
+  module TokenFor
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :token_definitions, instance_accessor: false, instance_predicate: false, default: {}
+      class_attribute :generated_token_verifier, instance_accessor: false, instance_predicate: false
+    end
+
+    TokenDefinition = Struct.new(:defining_class, :purpose, :expires_in, :block) do # :nodoc:
+      def full_purpose
+        @full_purpose ||= [defining_class.name, purpose, expires_in].join("\n")
+      end
+
+      def message_verifier
+        defining_class.generated_token_verifier
+      end
+
+      def payload_for(model)
+        block ? [model.id, model.instance_eval(&block).as_json] : [model.id]
+      end
+
+      def generate_token(model)
+        message_verifier.generate(payload_for(model), expires_in: expires_in, purpose: full_purpose)
+      end
+
+      def resolve_token(token)
+        payload = message_verifier.verified(token, purpose: full_purpose)
+        model = yield(payload[0]) if payload
+        model if model && payload_for(model) == payload
+      end
+    end
+
+    module ClassMethods
+      # Defines the behavior of tokens generated for a specific +purpose+.
+      # A token can be generated by calling TokenFor#generate_token_for on a
+      # record. Later, that record can be fetched by calling #find_by_token_for
+      # (or #find_by_token_for!) with the same purpose and token.
+      #
+      # Tokens are signed so that they are tamper-proof. Thus they can be
+      # exposed to outside world as, for example, password reset tokens.
+      #
+      # By default, tokens do not expire. They can be configured to expire by
+      # specifying a duration via the +expires_in+ option. The duration becomes
+      # part of the token's signature, so changing the value of +expires_in+
+      # will automatically invalidate previously generated tokens.
+      #
+      # A block may also be specified. When generating a token with
+      # TokenFor#generate_token_for, the block will be evaluated in the context
+      # of the record, and its return value will be embedded in the token as
+      # JSON. Later, when fetching the record with #find_by_token_for, the block
+      # will be evaluated again in the context of the fetched record. If the two
+      # JSON values do not match, the token will be treated as invalid. Note
+      # that the value returned by the block <b>should not contain sensitive
+      # information</b> because it will be embedded in the token as
+      # <b>human-readable plaintext JSON</b>.
+      #
+      # ==== Examples
+      #
+      #   class User < ActiveRecord::Base
+      #     has_secure_password
+      #
+      #     generates_token_for :password_reset, expires_in: 15.minutes do
+      #       # Last 10 characters of password salt, which changes when password is updated:
+      #       password_salt&.last(10)
+      #     end
+      #   end
+      #
+      #   user = User.first
+      #
+      #   token = user.generate_token_for(:password_reset)
+      #   User.find_by_token_for(:password_reset, token) # => user
+      #   # 16 minutes later...
+      #   User.find_by_token_for(:password_reset, token) # => nil
+      #
+      #   token = user.generate_token_for(:password_reset)
+      #   User.find_by_token_for(:password_reset, token) # => user
+      #   user.update!(password: "new password")
+      #   User.find_by_token_for(:password_reset, token) # => nil
+      def generates_token_for(purpose, expires_in: nil, &block)
+        self.token_definitions = token_definitions.merge(purpose => TokenDefinition.new(self, purpose, expires_in, block))
+      end
+
+      # Finds a record using a given +token+ for a predefined +purpose+. Returns
+      # +nil+ if the token is invalid or the record was not found.
+      def find_by_token_for(purpose, token)
+        raise UnknownPrimaryKey.new(self) unless primary_key
+        token_definitions.fetch(purpose).resolve_token(token) { |id| find_by(primary_key => id) }
+      end
+
+      # Finds a record using a given +token+ for a predefined +purpose+. Raises
+      # ActiveSupport::MessageVerifier::InvalidSignature if the token is invalid
+      # (e.g. expired, bad format, etc). Raises ActiveRecord::RecordNotFound if
+      # the token is valid but the record was not found.
+      def find_by_token_for!(purpose, token)
+        token_definitions.fetch(purpose).resolve_token(token) { |id| find(id) } ||
+          (raise ActiveSupport::MessageVerifier::InvalidSignature)
+      end
+    end
+
+    # Generates a token for a predefined +purpose+.
+    #
+    # Use ClassMethods#generates_token_for to define a token purpose and
+    # behavior.
+    def generate_token_for(purpose)
+      self.class.token_definitions.fetch(purpose).generate_token(self)
+    end
+  end
+end

data/lib/active_record/touch_later.rb

@@ -24,9 +24,13 @@ module ActiveRecord
       @_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|
+      self.class.reflect_on_all_associations.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)
+          if r.macro == :belongs_to
+            ActiveRecord::Associations::Builder::BelongsTo.touch_record(self, changes_to_save, r.foreign_key, r.name, touch)
+          elsif r.macro == :has_one
+            ActiveRecord::Associations::Builder::HasOne.touch_record(self, r.name, touch)
+          end
         end
       end
     end
@@ -42,6 +46,11 @@ module ActiveRecord
     end
 
     private
+      def init_internals
+        super
+        @_defer_touch_attrs = nil
+      end
+
       def surreptitiously_touch(attr_names)
         attr_names.each do |attr_name|
           _write_attribute(attr_name, @_touch_time)
@@ -57,9 +66,5 @@ module ActiveRecord
       def has_defer_touch_attrs?
         defined?(@_defer_touch_attrs) && @_defer_touch_attrs.present?
       end
-
-      def belongs_to_touch_method
-        :touch_later
-      end
   end
 end

data/lib/active_record/transactions.rb

@@ -13,7 +13,9 @@ module ActiveRecord
                        scope: [:kind, :name]
     end
 
-    # = Active Record Transactions
+    attr_accessor :_new_record_before_last_commit # :nodoc:
+
+    # = Active Record \Transactions
     #
     # \Transactions are protective blocks where SQL statements are only permanent
     # if they can all succeed as one atomic action. The classic example is a
@@ -98,7 +100,8 @@ module ActiveRecord
     # catch those in your application code.
     #
     # One exception is the ActiveRecord::Rollback exception, which will trigger
-    # a ROLLBACK when raised, but not be re-raised by the transaction block.
+    # a ROLLBACK when raised, but not be re-raised by the transaction block. Any
+    # other exception will be re-raised.
     #
     # *Warning*: one should not catch ActiveRecord::StatementInvalid exceptions
     # inside a transaction block. ActiveRecord::StatementInvalid exceptions indicate that an
@@ -227,31 +230,31 @@ module ActiveRecord
       #   after_commit :do_bar_baz, on: [:update, :destroy]
       #
       def after_commit(*args, &block)
-        set_options_for_callbacks!(args)
+        set_options_for_callbacks!(args, prepend_option)
         set_callback(:commit, :after, *args, &block)
       end
 
       # Shortcut for <tt>after_commit :hook, on: [ :create, :update ]</tt>.
       def after_save_commit(*args, &block)
-        set_options_for_callbacks!(args, on: [ :create, :update ])
+        set_options_for_callbacks!(args, on: [ :create, :update ], **prepend_option)
         set_callback(:commit, :after, *args, &block)
       end
 
       # Shortcut for <tt>after_commit :hook, on: :create</tt>.
       def after_create_commit(*args, &block)
-        set_options_for_callbacks!(args, on: :create)
+        set_options_for_callbacks!(args, on: :create, **prepend_option)
         set_callback(:commit, :after, *args, &block)
       end
 
       # Shortcut for <tt>after_commit :hook, on: :update</tt>.
       def after_update_commit(*args, &block)
-        set_options_for_callbacks!(args, on: :update)
+        set_options_for_callbacks!(args, on: :update, **prepend_option)
         set_callback(:commit, :after, *args, &block)
       end
 
       # Shortcut for <tt>after_commit :hook, on: :destroy</tt>.
       def after_destroy_commit(*args, &block)
-        set_options_for_callbacks!(args, on: :destroy)
+        set_options_for_callbacks!(args, on: :destroy, **prepend_option)
         set_callback(:commit, :after, *args, &block)
       end
 
@@ -259,11 +262,19 @@ module ActiveRecord
       #
       # Please check the documentation of #after_commit for options.
       def after_rollback(*args, &block)
-        set_options_for_callbacks!(args)
+        set_options_for_callbacks!(args, prepend_option)
         set_callback(:rollback, :after, *args, &block)
       end
 
       private
+        def prepend_option
+          if ActiveRecord.run_after_transaction_callbacks_in_order_defined
+            { prepend: true }
+          else
+            {}
+          end
+        end
+
         def set_options_for_callbacks!(args, enforced_options = {})
           options = args.extract_options!.merge!(enforced_options)
           args << options
@@ -336,9 +347,9 @@ module ActiveRecord
       @_trigger_update_callback = @_trigger_destroy_callback = false if force_restore_state
     end
 
-    # Executes +method+ within a transaction and captures its return value as a
-    # status flag. If the status is true the transaction is committed, otherwise
-    # a ROLLBACK is issued. In any case the status flag is returned.
+    # Executes a block within a transaction and captures its return value as a
+    # status flag. If the status is true, the transaction is committed,
+    # otherwise a ROLLBACK is issued. In any case, the status flag is returned.
     #
     # This method is available within the context of an ActiveRecord::Base
     # instance.
@@ -365,6 +376,13 @@ module ActiveRecord
     private
       attr_reader :_committed_already_called, :_trigger_update_callback, :_trigger_destroy_callback
 
+      def init_internals
+        super
+        @_start_transaction_state = nil
+        @_committed_already_called = nil
+        @_new_record_before_last_commit = nil
+      end
+
       # Save the new record state and id of a record so it can be restored later if a transaction fails.
       def remember_transaction_record_state
         @_start_transaction_state ||= {
@@ -406,8 +424,16 @@ module ActiveRecord
             end
             @mutations_from_database = nil
             @mutations_before_last_save = nil
-            if @attributes.fetch_value(@primary_key) != restore_state[:id]
-              @attributes.write_from_user(@primary_key, restore_state[:id])
+            if self.class.composite_primary_key?
+              if restore_state[:id] != @primary_key.map { |col| @attributes.fetch_value(col) }
+                @primary_key.zip(restore_state[:id]).each do |col, val|
+                  @attributes.write_from_user(col, val)
+                end
+              end
+            else
+              if @attributes.fetch_value(@primary_key) != restore_state[:id]
+                @attributes.write_from_user(@primary_key, restore_state[:id])
+              end
             end
             freeze if restore_state[:frozen?]
           end

data/lib/active_record/translation.rb

@@ -16,7 +16,7 @@ module ActiveRecord
       classes
     end
 
-    # Set the i18n scope to overwrite ActiveModel.
+    # Set the i18n scope to override ActiveModel.
     def i18n_scope # :nodoc:
       :activerecord
     end

data/lib/active_record/type/adapter_specific_registry.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_model/type/registry"
-
 module ActiveRecord
   # :stopdoc:
   module Type
@@ -12,7 +10,6 @@ module ActiveRecord
 
       def initialize_copy(other)
         @registrations = @registrations.dup
-        super
       end
 
       def add_modifier(options, klass, **args)
@@ -56,11 +53,7 @@ module ActiveRecord
       end
 
       def call(_registry, *args, adapter: nil, **kwargs)
-        if kwargs.any? # https://bugs.ruby-lang.org/issues/10856
-          block.call(*args, **kwargs)
-        else
-          block.call(*args)
-        end
+        block.call(*args, **kwargs)
       end
 
       def matches?(type_name, *args, **kwargs)

data/lib/active_record/type/internal/timezone.rb

@@ -4,12 +4,17 @@ module ActiveRecord
   module Type
     module Internal
       module Timezone
+        def initialize(timezone: nil, **kwargs)
+          super(**kwargs)
+          @timezone = timezone
+        end
+
         def is_utc?
-          ActiveRecord.default_timezone == :utc
+          default_timezone == :utc
         end
 
         def default_timezone
-          ActiveRecord.default_timezone
+          @timezone || ActiveRecord.default_timezone
         end
       end
     end

data/lib/active_record/type/serialized.rb

@@ -55,6 +55,10 @@ module ActiveRecord
         coder.respond_to?(:object_class) && value.is_a?(coder.object_class)
       end
 
+      def serialized? # :nodoc:
+        true
+      end
+
       private
         def default_value?(value)
           value == coder.load(nil)
@@ -63,11 +67,11 @@ module ActiveRecord
         def encoded(value)
           return if default_value?(value)
           payload = coder.dump(value)
-          if payload && binary? && payload.encoding != Encoding::BINARY
-            payload = payload.dup if payload.frozen?
-            payload.force_encoding(Encoding::BINARY)
+          if payload && @subtype.binary?
+            ActiveModel::Type::Binary::Data.new(payload)
+          else
+            payload
           end
-          payload
         end
     end
   end

data/lib/active_record/type/time.rb

@@ -17,6 +17,10 @@ module ActiveRecord
         end
       end
 
+      def serialize_cast_value(value) # :nodoc:
+        Value.new(super) if value
+      end
+
       private
         def cast_value(value)
           case value = super

data/lib/active_record/validations/absence.rb

@@ -14,7 +14,7 @@ module ActiveRecord
     module ClassMethods
       # Validates that the specified attributes are not present (as defined by
       # Object#present?). If the attribute is an association, the associated object
-      # is considered absent if it was marked for destruction.
+      # is also considered not present if it is marked for destruction.
       #
       # See ActiveModel::Validations::HelperMethods.validates_absence_of for more information.
       def validates_absence_of(*attr_names)

data/lib/active_record/validations/associated.rb

@@ -42,14 +42,14 @@ module ActiveRecord
       #   or an array of symbols. (e.g. <tt>on: :create</tt> or
       #   <tt>on: :custom_validation_context</tt> or
       #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to
       #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
       #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a +true+ or +false+
+      #   method, proc, or string should return or evaluate to a +true+ or +false+
       #   value.
       def validates_associated(*attr_names)
         validates_with AssociatedValidator, _merge_attributes(attr_names)

data/lib/active_record/validations/numericality.rb

@@ -21,10 +21,11 @@ module ActiveRecord
 
     module ClassMethods
       # Validates whether the value of the specified attribute is numeric by
-      # trying to convert it to a float with Kernel.Float (if <tt>only_integer</tt>
-      # is +false+) or applying it to the regular expression <tt>/\A[\+\-]?\d+\z/</tt>
-      # (if <tt>only_integer</tt> is set to +true+). Kernel.Float precision
-      # defaults to the column's precision value or 15.
+      # trying to convert it to a float with +Kernel.Float+ (if
+      # <tt>only_integer</tt> is +false+) or applying it to the regular
+      # expression <tt>/\A[\+\-]?\d+\z/</tt> (if <tt>only_integer</tt> is set to
+      # +true+). +Kernel.Float+ precision defaults to the column's precision
+      # value or 15.
       #
       # See ActiveModel::Validations::HelperMethods.validates_numericality_of for more information.
       def validates_numericality_of(*attr_names)

data/lib/active_record/validations/presence.rb

@@ -13,9 +13,8 @@ module ActiveRecord
 
     module ClassMethods
       # Validates that the specified attributes are not blank (as defined by
-      # Object#blank?), and, if the attribute is an association, that the
-      # associated object is not marked for destruction. Happens by default
-      # on save.
+      # Object#blank?). If the attribute is an association, the associated object
+      # is also considered blank if it is marked for destruction.
       #
       #   class Person < ActiveRecord::Base
       #     has_one :face
@@ -25,41 +24,19 @@ module ActiveRecord
       # The face attribute must be in the object and it cannot be blank or marked
       # for destruction.
       #
-      # If you want to validate the presence of a boolean field (where the real values
-      # are true and false), you will want to use
-      # <tt>validates_inclusion_of :field_name, in: [true, false]</tt>.
-      #
-      # This is due to the way Object#blank? handles boolean values:
-      # <tt>false.blank? # => true</tt>.
-      #
       # This validator defers to the Active Model validation for presence, adding the
       # check to see that an associated object is not marked for destruction. This
       # prevents the parent object from validating successfully and saving, which then
       # deletes the associated object, thus putting the parent object into an invalid
       # state.
       #
+      # See ActiveModel::Validations::HelperMethods.validates_presence_of for
+      # more information.
+      #
       # NOTE: This validation will not fail while using it with an association
       # if the latter was assigned but not valid. If you want to ensure that
       # it is both present and valid, you also need to use
       # {validates_associated}[rdoc-ref:Validations::ClassMethods#validates_associated].
-      #
-      # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "can't be blank").
-      # * <tt>:on</tt> - Specifies the contexts where this validation is active.
-      #   Runs in all validation contexts by default +nil+. You can pass a symbol
-      #   or an array of symbols. (e.g. <tt>on: :create</tt> or
-      #   <tt>on: :custom_validation_context</tt> or
-      #   <tt>on: [:create, :custom_validation_context]</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if
-      #   the validation should occur (e.g. <tt>if: :allow_validation</tt>, or
-      #   <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method, proc
-      #   or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine
-      #   if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
-      #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The method,
-      #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:strict</tt> - Specifies whether validation should be strict.
-      #   See ActiveModel::Validations#validates! for more information.
       def validates_presence_of(*attr_names)
         validates_with PresenceValidator, _merge_attributes(attr_names)
       end

data/lib/active_record/validations/uniqueness.rb

@@ -20,10 +20,12 @@ module ActiveRecord
         finder_class = find_finder_class_for(record)
         value = map_enum_attribute(finder_class, attribute, value)
 
+        return if record.persisted? && !validation_needed?(finder_class, record, attribute)
+
         relation = build_relation(finder_class, attribute, value)
         if record.persisted?
           if finder_class.primary_key
-            relation = relation.where.not(finder_class.primary_key => record.id_in_database)
+            relation = relation.where.not(finder_class.primary_key => [record.id_in_database])
           else
             raise UnknownPrimaryKey.new(finder_class, "Cannot validate uniqueness for persisted record without primary key.")
           end
@@ -64,6 +66,48 @@ module ActiveRecord
         class_hierarchy.detect { |klass| !klass.abstract_class? }
       end
 
+      def validation_needed?(klass, record, attribute)
+        return true if options[:conditions] || options.key?(:case_sensitive)
+
+        scope = Array(options[:scope])
+        attributes = scope + [attribute]
+        attributes = resolve_attributes(record, attributes)
+
+        return true if attributes.any? { |attr| record.attribute_changed?(attr) ||
+                                                record.read_attribute(attr).nil? }
+
+        !covered_by_unique_index?(klass, record, attribute, scope)
+      end
+
+      def covered_by_unique_index?(klass, record, attribute, scope)
+        @covered ||= self.attributes.map(&:to_s).select do |attr|
+          attributes = scope + [attr]
+          attributes = resolve_attributes(record, attributes)
+
+          klass.connection.schema_cache.indexes(klass.table_name).any? do |index|
+            index.unique &&
+              index.where.nil? &&
+              (Array(index.columns) - attributes).empty?
+          end
+        end
+
+        @covered.include?(attribute.to_s)
+      end
+
+      def resolve_attributes(record, attributes)
+        attributes.flat_map do |attribute|
+          reflection = record.class._reflect_on_association(attribute)
+
+          if reflection.nil?
+            attribute.to_s
+          elsif reflection.polymorphic?
+            [reflection.foreign_key, reflection.foreign_type]
+          else
+            reflection.foreign_key
+          end
+        end
+      end
+
       def build_relation(klass, attribute, value)
         relation = klass.unscoped
         comparison = relation.bind_attribute(attribute, value) do |attr, bind|
@@ -166,14 +210,14 @@ module ActiveRecord
       #   attribute is +nil+ (default is +false+).
       # * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the
       #   attribute is blank (default is +false+).
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      # * <tt>:if</tt> - Specifies a method, proc, or string to call to determine
       #   if the validation should occur (e.g. <tt>if: :allow_validation</tt>,
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to
+      # * <tt>:unless</tt> - Specifies a method, proc, or string to call to
       #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
       #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
-      #   method, proc or string should return or evaluate to a +true+ or +false+
+      #   method, proc, or string should return or evaluate to a +true+ or +false+
       #   value.
       #
       # === Concurrency and integrity
@@ -221,7 +265,7 @@ module ActiveRecord
       # When the database catches such a duplicate insertion,
       # {ActiveRecord::Base#save}[rdoc-ref:Persistence#save] will raise an ActiveRecord::StatementInvalid
       # exception. You can either choose to let this error propagate (which
-      # will result in the default Rails exception page being shown), or you
+      # will result in the default \Rails exception page being shown), or you
       # can catch it and restart the transaction (e.g. by telling the user
       # that the title already exists, and asking them to re-enter the title).
       # This technique is also known as
@@ -236,6 +280,7 @@ module ActiveRecord
       # The following bundled adapters throw the ActiveRecord::RecordNotUnique exception:
       #
       # * ActiveRecord::ConnectionAdapters::Mysql2Adapter.
+      # * ActiveRecord::ConnectionAdapters::TrilogyAdapter.
       # * ActiveRecord::ConnectionAdapters::SQLite3Adapter.
       # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.
       def validates_uniqueness_of(*attr_names)

data/lib/active_record/validations.rb

@@ -30,10 +30,12 @@ module ActiveRecord
 
   # = Active Record \Validations
   #
-  # Active Record includes the majority of its validations from ActiveModel::Validations
-  # all of which accept the <tt>:on</tt> argument to define the context where the
-  # validations are active. Active Record will always supply either the context of
-  # <tt>:create</tt> or <tt>:update</tt> dependent on whether the model is a
+  # Active Record includes the majority of its validations from ActiveModel::Validations.
+  #
+  # In Active Record, all validations are performed on save by default.
+  # Validations accept the <tt>:on</tt> argument to define the context where
+  # the validations are active. Active Record will pass either the context of
+  # <tt>:create</tt> or <tt>:update</tt> depending on whether the model is a
   # {new_record?}[rdoc-ref:Persistence#new_record?].
   module Validations
     extend ActiveSupport::Concern
@@ -60,6 +62,8 @@ module ActiveRecord
     #
     # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
     # {new_record?}[rdoc-ref:Persistence#new_record?] is +true+, and to <tt>:update</tt> if it is not.
+    # If the argument is an array of contexts, <tt>post.valid?([:create, :update])</tt>, the validations are
+    # run within multiple contexts.
     #
     # \Validations with no <tt>:on</tt> option will run no matter the context. \Validations with
     # some <tt>:on</tt> option will only run in the specified context.

data/lib/active_record/version.rb

@@ -3,7 +3,7 @@
 require_relative "gem_version"
 
 module ActiveRecord
-  # Returns the version of the currently loaded ActiveRecord as a <tt>Gem::Version</tt>
+  # Returns the currently loaded version of Active Record as a +Gem::Version+.
   def self.version
     gem_version
   end