activerecord 6.1.4.6 → 7.0.2.3

data/lib/active_record/tasks/database_tasks.rb

@@ -39,17 +39,23 @@ module ActiveRecord
       ##
       # :singleton-method:
       # Extra flags passed to database CLI tool (mysqldump/pg_dump) when calling db:schema:dump
+      # It can be used as a string/array (the typical case) or a hash (when you use multiple adapters)
+      # Example:
+      #   ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = {
+      #     mysql2: ['--no-defaults', '--skip-add-drop-table'],
+      #     postgres: '--no-tablespaces'
+      #   }
       mattr_accessor :structure_dump_flags, instance_accessor: false
 
       ##
       # :singleton-method:
       # Extra flags passed to database CLI tool when calling db:schema:load
+      # It can be used as a string/array (the typical case) or a hash (when you use multiple adapters)
       mattr_accessor :structure_load_flags, instance_accessor: false
 
       extend self
 
-      attr_writer :current_config, :db_dir, :migrations_paths, :fixtures_path, :root, :env, :seed_loader
-      deprecate :current_config=
+      attr_writer :db_dir, :migrations_paths, :fixtures_path, :root, :env, :seed_loader
       attr_accessor :database_configuration
 
       LOCAL_HOSTS = ["127.0.0.1", "localhost"]
@@ -103,11 +109,6 @@ module ActiveRecord
         @env ||= Rails.env
       end
 
-      def spec
-        @spec ||= "primary"
-      end
-      deprecate spec: "please use name instead"
-
       def name
         @name ||= "primary"
       end
@@ -116,18 +117,6 @@ module ActiveRecord
         @seed_loader ||= Rails.application
       end
 
-      def current_config(options = {})
-        if options.has_key?(:config)
-          @current_config = options[:config]
-        else
-          env_name = options[:env] || env
-          name = options[:spec] || "primary"
-
-          @current_config ||= ActiveRecord::Base.configurations.configs_for(env_name: env_name, name: name)&.configuration_hash
-        end
-      end
-      deprecate :current_config
-
       def create(configuration, *arguments)
         db_config = resolve_configuration(configuration)
         database_adapter_for(db_config, *arguments).create
@@ -154,7 +143,7 @@ module ActiveRecord
         begin
           Rails.application.config.load_database_yaml
         rescue
-          unless ActiveRecord::Base.suppress_multiple_database_warning
+          unless ActiveRecord.suppress_multiple_database_warning
             $stderr.puts "Rails couldn't infer whether you are using multiple databases from your database.yml and can't generate the tasks for the non-primary databases. If you'd like to use this feature, please simplify your ERB."
           end
 
@@ -171,12 +160,14 @@ module ActiveRecord
         return if database_configs.count == 1
 
         database_configs.each do |db_config|
+          next unless db_config.database_tasks?
+
           yield db_config.name
         end
       end
 
       def raise_for_multi_db(environment = env, command:)
-        db_configs = ActiveRecord::Base.configurations.configs_for(env_name: environment)
+        db_configs = configs_for(env_name: environment)
 
         if db_configs.count > 1
           dbs_list = []
@@ -194,6 +185,38 @@ module ActiveRecord
         ActiveRecord::Base.establish_connection(environment.to_sym)
       end
 
+      def prepare_all
+        seed = false
+
+        configs_for(env_name: env).each do |db_config|
+          ActiveRecord::Base.establish_connection(db_config)
+
+          # Skipped when no database
+          migrate
+
+          if ActiveRecord.dump_schema_after_migration
+            dump_schema(db_config, ActiveRecord.schema_format)
+          end
+        rescue ActiveRecord::NoDatabaseError
+          create_current(db_config.env_name, db_config.name)
+
+          if File.exist?(schema_dump_path(db_config))
+            load_schema(
+              db_config,
+              ActiveRecord.schema_format,
+              nil
+            )
+          else
+            migrate
+          end
+
+          seed = true
+        end
+
+        ActiveRecord::Base.establish_connection
+        load_seed if seed
+      end
+
       def drop(configuration, *arguments)
         db_config = resolve_configuration(configuration)
         database_adapter_for(db_config, *arguments).drop
@@ -223,19 +246,25 @@ module ActiveRecord
       private :truncate_tables
 
       def truncate_all(environment = env)
-        ActiveRecord::Base.configurations.configs_for(env_name: environment).each do |db_config|
+        configs_for(env_name: environment).each do |db_config|
           truncate_tables(db_config)
         end
       end
 
-      def migrate
+      def migrate(version = nil)
         check_target_version
 
         scope = ENV["SCOPE"]
         verbose_was, Migration.verbose = Migration.verbose, verbose?
 
         Base.connection.migration_context.migrate(target_version) do |migration|
-          scope.blank? || scope == migration.scope
+          if version.blank?
+            scope.blank? || scope == migration.scope
+          else
+            migration.version == version
+          end
+        end.tap do |migrations_ran|
+          Migration.write("No migrations ran. (using #{scope} scope)") if scope.present? && migrations_ran.empty?
         end
 
         ActiveRecord::Base.clear_cache!
@@ -243,6 +272,23 @@ module ActiveRecord
         Migration.verbose = verbose_was
       end
 
+      def db_configs_with_versions(db_configs) # :nodoc:
+        db_configs_with_versions = Hash.new { |h, k| h[k] = [] }
+
+        db_configs.each do |db_config|
+          ActiveRecord::Base.establish_connection(db_config)
+          versions_to_run = ActiveRecord::Base.connection.migration_context.pending_migration_versions
+          target_version = ActiveRecord::Tasks::DatabaseTasks.target_version
+
+          versions_to_run.each do |version|
+            next if target_version && target_version != version
+            db_configs_with_versions[version] << db_config
+          end
+        end
+
+        db_configs_with_versions
+      end
+
       def migrate_status
         unless ActiveRecord::Base.connection.schema_migration.table_exists?
           Kernel.abort "Schema migrations table does not exist yet."
@@ -269,7 +315,7 @@ module ActiveRecord
       end
 
       def charset_current(env_name = env, db_name = name)
-        db_config = ActiveRecord::Base.configurations.configs_for(env_name: env_name, name: db_name)
+        db_config = configs_for(env_name: env_name, name: db_name)
         charset(db_config)
       end
 
@@ -279,7 +325,7 @@ module ActiveRecord
       end
 
       def collation_current(env_name = env, db_name = name)
-        db_config = ActiveRecord::Base.configurations.configs_for(env_name: env_name, name: db_name)
+        db_config = configs_for(env_name: env_name, name: db_name)
         collation(db_config)
       end
 
@@ -305,17 +351,19 @@ module ActiveRecord
       def structure_dump(configuration, *arguments)
         db_config = resolve_configuration(configuration)
         filename = arguments.delete_at(0)
-        database_adapter_for(db_config, *arguments).structure_dump(filename, structure_dump_flags)
+        flags = structure_dump_flags_for(db_config.adapter)
+        database_adapter_for(db_config, *arguments).structure_dump(filename, flags)
       end
 
       def structure_load(configuration, *arguments)
         db_config = resolve_configuration(configuration)
         filename = arguments.delete_at(0)
-        database_adapter_for(db_config, *arguments).structure_load(filename, structure_load_flags)
+        flags = structure_load_flags_for(db_config.adapter)
+        database_adapter_for(db_config, *arguments).structure_load(filename, flags)
       end
 
-      def load_schema(db_config, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
-        file ||= dump_filename(db_config.name, format)
+      def load_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
+        file ||= schema_dump_path(db_config, format)
 
         verbose_was, Migration.verbose = Migration.verbose, verbose? && ENV["VERBOSE"]
         check_schema_file(file)
@@ -336,16 +384,10 @@ module ActiveRecord
         Migration.verbose = verbose_was
       end
 
-      def schema_up_to_date?(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = nil, name = nil)
+      def schema_up_to_date?(configuration, format = ActiveRecord.schema_format, file = nil)
         db_config = resolve_configuration(configuration)
 
-        if environment || name
-          ActiveSupport::Deprecation.warn("`environment` and `name` will be removed as parameters in 6.2.0, you may now pass an ActiveRecord::DatabaseConfigurations::DatabaseConfig as `configuration` instead.")
-        end
-
-        name ||= db_config.name
-
-        file ||= dump_filename(name, format)
+        file ||= schema_dump_path(db_config)
 
         return true unless File.exist?(file)
 
@@ -357,8 +399,8 @@ module ActiveRecord
         ActiveRecord::InternalMetadata[:schema_sha1] == schema_sha1(file)
       end
 
-      def reconstruct_from_schema(db_config, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
-        file ||= dump_filename(db_config.name, format)
+      def reconstruct_from_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
+        file ||= schema_dump_path(db_config, format)
 
         check_schema_file(file)
 
@@ -375,9 +417,9 @@ module ActiveRecord
         load_schema(db_config, format, file)
       end
 
-      def dump_schema(db_config, format = ActiveRecord::Base.schema_format) # :nodoc:
+      def dump_schema(db_config, format = ActiveRecord.schema_format) # :nodoc:
         require "active_record/schema_dumper"
-        filename = dump_filename(db_config.name, format)
+        filename = schema_dump_path(db_config, format)
         connection = ActiveRecord::Base.connection
 
         FileUtils.mkdir_p(db_dir)
@@ -397,11 +439,7 @@ module ActiveRecord
         end
       end
 
-      def schema_file(format = ActiveRecord::Base.schema_format)
-        File.join(db_dir, schema_file_type(format))
-      end
-
-      def schema_file_type(format = ActiveRecord::Base.schema_format)
+      def schema_file_type(format = ActiveRecord.schema_format)
         case format
         when :ruby
           "schema.rb"
@@ -409,15 +447,19 @@ module ActiveRecord
           "structure.sql"
         end
       end
+      deprecate :schema_file_type
 
-      def dump_filename(db_config_name, format = ActiveRecord::Base.schema_format)
-        filename = if ActiveRecord::Base.configurations.primary?(db_config_name)
-          schema_file_type(format)
+      def schema_dump_path(db_config, format = ActiveRecord.schema_format)
+        return ENV["SCHEMA"] if ENV["SCHEMA"]
+
+        filename = db_config.schema_dump(format)
+        return unless filename
+
+        if File.dirname(filename) == ActiveRecord::Tasks::DatabaseTasks.db_dir
+          filename
         else
-          "#{db_config_name}_#{schema_file_type(format)}"
+          File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
         end
-
-        ENV["SCHEMA"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
       end
 
       def cache_dump_filename(db_config_name, schema_cache_path: nil)
@@ -430,7 +472,7 @@ module ActiveRecord
         schema_cache_path || ENV["SCHEMA_CACHE"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
       end
 
-      def load_schema_current(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
+      def load_schema_current(format = ActiveRecord.schema_format, file = nil, environment = env)
         each_current_configuration(environment) do |db_config|
           load_schema(db_config, format, file)
         end
@@ -468,6 +510,10 @@ module ActiveRecord
       end
 
       private
+        def configs_for(**options)
+          Base.configurations.configs_for(**options)
+        end
+
         def resolve_configuration(configuration)
           Base.configurations.resolve(configuration)
         end
@@ -488,7 +534,7 @@ module ActiveRecord
         end
 
         def class_for_adapter(adapter)
-          _key, task = @tasks.each_pair.detect { |pattern, _task| adapter[pattern] }
+          _key, task = @tasks.reverse_each.detect { |pattern, _task| adapter[pattern] }
           unless task
             raise DatabaseNotSupported, "Rake tasks not supported by '#{adapter}' adapter"
           end
@@ -500,7 +546,7 @@ module ActiveRecord
           environments << "test" if environment == "development" && !ENV["SKIP_TEST_DATABASE"] && !ENV["DATABASE_URL"]
 
           environments.each do |env|
-            ActiveRecord::Base.configurations.configs_for(env_name: env).each do |db_config|
+            configs_for(env_name: env).each do |db_config|
               next if name && name != db_config.name
 
               yield db_config
@@ -509,7 +555,7 @@ module ActiveRecord
         end
 
         def each_local_configuration
-          ActiveRecord::Base.configurations.configs_for.each do |db_config|
+          configs_for.each do |db_config|
             next unless db_config.database
 
             if local_database?(db_config)
@@ -526,7 +572,23 @@ module ActiveRecord
         end
 
         def schema_sha1(file)
-          Digest::SHA1.hexdigest(File.read(file))
+          OpenSSL::Digest::SHA1.hexdigest(File.read(file))
+        end
+
+        def structure_dump_flags_for(adapter)
+          if structure_dump_flags.is_a?(Hash)
+            structure_dump_flags[adapter.to_sym]
+          else
+            structure_dump_flags
+          end
+        end
+
+        def structure_load_flags_for(adapter)
+          if structure_load_flags.is_a?(Hash)
+            structure_load_flags[adapter.to_sym]
+          else
+            structure_load_flags
+          end
         end
     end
   end

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -94,7 +94,7 @@ module ActiveRecord
             sslcapath: "--ssl-capath",
             sslcipher: "--ssl-cipher",
             sslkey:    "--ssl-key"
-          }.map { |opt, arg| "#{arg}=#{configuration_hash[opt]}" if configuration_hash[opt] }.compact
+          }.filter_map { |opt, arg| "#{arg}=#{configuration_hash[opt]}" if configuration_hash[opt] }
 
           args
         end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -47,20 +47,22 @@ module ActiveRecord
       end
 
       def structure_dump(filename, extra_flags)
-        set_psql_env
-
         search_path = \
-          case ActiveRecord::Base.dump_schemas
+          case ActiveRecord.dump_schemas
           when :schema_search_path
             configuration_hash[:schema_search_path]
           when :all
             nil
           when String
-            ActiveRecord::Base.dump_schemas
+            ActiveRecord.dump_schemas
           end
 
-        args = ["--schema-only", "--no-privileges", "--no-owner", "--file", filename]
+        args = ["--schema-only", "--no-privileges", "--no-owner"]
+        args << "--no-comments" if connection.database_version >= 110_000
+        args.concat(["--file", filename])
+
         args.concat(Array(extra_flags)) if extra_flags
+
         unless search_path.blank?
           args += search_path.split(",").map do |part|
             "--schema=#{part.strip}"
@@ -79,7 +81,6 @@ module ActiveRecord
       end
 
       def structure_load(filename, extra_flags)
-        set_psql_env
         args = ["--set", ON_ERROR_STOP_1, "--quiet", "--no-psqlrc", "--file", filename]
         args.concat(Array(extra_flags)) if extra_flags
         args << db_config.database
@@ -100,15 +101,21 @@ module ActiveRecord
           )
         end
 
-        def set_psql_env
-          ENV["PGHOST"]     = db_config.host                     if db_config.host
-          ENV["PGPORT"]     = configuration_hash[:port].to_s     if configuration_hash[:port]
-          ENV["PGPASSWORD"] = configuration_hash[:password].to_s if configuration_hash[:password]
-          ENV["PGUSER"]     = configuration_hash[:username].to_s if configuration_hash[:username]
+        def psql_env
+          {}.tap do |env|
+            env["PGHOST"]         = db_config.host                        if db_config.host
+            env["PGPORT"]         = configuration_hash[:port].to_s        if configuration_hash[:port]
+            env["PGPASSWORD"]     = configuration_hash[:password].to_s    if configuration_hash[:password]
+            env["PGUSER"]         = configuration_hash[:username].to_s    if configuration_hash[:username]
+            env["PGSSLMODE"]      = configuration_hash[:sslmode].to_s     if configuration_hash[:sslmode]
+            env["PGSSLCERT"]      = configuration_hash[:sslcert].to_s     if configuration_hash[:sslcert]
+            env["PGSSLKEY"]       = configuration_hash[:sslkey].to_s      if configuration_hash[:sslkey]
+            env["PGSSLROOTCERT"]  = configuration_hash[:sslrootcert].to_s if configuration_hash[:sslrootcert]
+          end
         end
 
         def run_cmd(cmd, args, action)
-          fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
+          fail run_cmd_error(cmd, args, action) unless Kernel.system(psql_env, cmd, *args)
         end
 
         def run_cmd_error(cmd, args, action)

data/lib/active_record/test_databases.rb

@@ -14,7 +14,7 @@ module ActiveRecord
       ActiveRecord::Base.configurations.configs_for(env_name: env_name).each do |db_config|
         db_config._database = "#{db_config.database}-#{i}"
 
-        ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config, ActiveRecord::Base.schema_format, nil)
+        ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config, ActiveRecord.schema_format, nil)
       end
     ensure
       ActiveRecord::Base.establish_connection

data/lib/active_record/test_fixtures.rb

@@ -193,8 +193,8 @@ module ActiveRecord
       # need to share a connection pool so that the reading connection
       # can see data in the open transaction on the writing connection.
       def setup_shared_connection_pool
-        if ActiveRecord::Base.legacy_connection_handling
-          writing_handler = ActiveRecord::Base.connection_handlers[ActiveRecord::Base.writing_role]
+        if ActiveRecord.legacy_connection_handling
+          writing_handler = ActiveRecord::Base.connection_handlers[ActiveRecord.writing_role]
 
           ActiveRecord::Base.connection_handlers.values.each do |handler|
             if handler != writing_handler
@@ -221,7 +221,7 @@ module ActiveRecord
           handler.connection_pool_names.each do |name|
             pool_manager = handler.send(:owner_to_pool_manager)[name]
             pool_manager.shard_names.each do |shard_name|
-              writing_pool_config = pool_manager.get_pool_config(ActiveRecord::Base.writing_role, shard_name)
+              writing_pool_config = pool_manager.get_pool_config(ActiveRecord.writing_role, shard_name)
               @saved_pool_configs[name][shard_name] ||= {}
               pool_manager.role_names.each do |role|
                 next unless pool_config = pool_manager.get_pool_config(role, shard_name)
@@ -236,7 +236,7 @@ module ActiveRecord
       end
 
       def teardown_shared_connection_pool
-        if ActiveRecord::Base.legacy_connection_handling
+        if ActiveRecord.legacy_connection_handling
           @legacy_saved_pool_configs.each_pair do |handler, names|
             names.each_pair do |name, shards|
               shards.each_pair do |shard_name, pool_config|

data/lib/active_record/timestamp.rb

@@ -75,7 +75,7 @@ module ActiveRecord
       end
 
       def current_time_from_proper_timezone
-        default_timezone == :utc ? Time.now.utc : Time.now
+        ActiveRecord.default_timezone == :utc ? Time.now.utc : Time.now
       end
 
       private
@@ -127,7 +127,7 @@ module ActiveRecord
     end
 
     def should_record_timestamps?
-      record_timestamps && (!partial_writes? || has_changes_to_save?)
+      record_timestamps && (!partial_updates? || has_changes_to_save?)
     end
 
     def timestamp_attributes_for_create_in_model
@@ -148,8 +148,7 @@ module ActiveRecord
 
     def max_updated_column_timestamp
       timestamp_attributes_for_update_in_model
-        .map { |attr| self[attr]&.to_time }
-        .compact
+        .filter_map { |attr| self[attr]&.to_time }
         .max
     end
 

data/lib/active_record/transactions.rb

@@ -4,7 +4,7 @@ module ActiveRecord
   # See ActiveRecord::Transactions::ClassMethods for documentation.
   module Transactions
     extend ActiveSupport::Concern
-    #:nodoc:
+    # :nodoc:
     ACTIONS = [:create, :destroy, :update]
 
     included do
@@ -290,19 +290,19 @@ module ActiveRecord
       self.class.transaction(**options, &block)
     end
 
-    def destroy #:nodoc:
+    def destroy # :nodoc:
       with_transaction_returning_status { super }
     end
 
-    def save(**) #:nodoc:
+    def save(**) # :nodoc:
       with_transaction_returning_status { super }
     end
 
-    def save!(**) #:nodoc:
+    def save!(**) # :nodoc:
       with_transaction_returning_status { super }
     end
 
-    def touch(*, **) #:nodoc:
+    def touch(*, **) # :nodoc:
       with_transaction_returning_status { super }
     end
 
@@ -314,8 +314,8 @@ module ActiveRecord
     #
     # Ensure that it is not called if the object was never persisted (failed create),
     # but call it after the commit of a destroyed object.
-    def committed!(should_run_callbacks: true) #:nodoc:
-      force_clear_transaction_record_state
+    def committed!(should_run_callbacks: true) # :nodoc:
+      @_start_transaction_state = nil
       if should_run_callbacks
         @_committed_already_called = true
         _run_commit_callbacks
@@ -326,7 +326,7 @@ module ActiveRecord
 
     # Call the #after_rollback callbacks. The +force_restore_state+ argument indicates if the record
     # state should be rolled back to the beginning or just to the last savepoint.
-    def rolledback!(force_restore_state: false, should_run_callbacks: true) #:nodoc:
+    def rolledback!(force_restore_state: false, should_run_callbacks: true) # :nodoc:
       if should_run_callbacks
         _run_rollback_callbacks
       end
@@ -389,12 +389,7 @@ module ActiveRecord
       def clear_transaction_record_state
         return unless @_start_transaction_state
         @_start_transaction_state[:level] -= 1
-        force_clear_transaction_record_state if @_start_transaction_state[:level] < 1
-      end
-
-      # Force to clear the transaction record state.
-      def force_clear_transaction_record_state
-        @_start_transaction_state = nil
+        @_start_transaction_state = nil if @_start_transaction_state[:level] < 1
       end
 
       # Restore the new record state and id of a record that was previously saved by a call to save_record_state.

data/lib/active_record/translation.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     include ActiveModel::Translation
 
     # Set the lookup ancestors for ActiveModel.
-    def lookup_ancestors #:nodoc:
+    def lookup_ancestors # :nodoc:
       klass = self
       classes = [klass]
       return classes if klass == ActiveRecord::Base
@@ -17,7 +17,7 @@ module ActiveRecord
     end
 
     # Set the i18n scope to overwrite ActiveModel.
-    def i18n_scope #:nodoc:
+    def i18n_scope # :nodoc:
       :activerecord
     end
   end

data/lib/active_record/type/adapter_specific_registry.rb

@@ -5,15 +5,40 @@ require "active_model/type/registry"
 module ActiveRecord
   # :stopdoc:
   module Type
-    class AdapterSpecificRegistry < ActiveModel::Type::Registry
+    class AdapterSpecificRegistry # :nodoc:
+      def initialize
+        @registrations = []
+      end
+
+      def initialize_copy(other)
+        @registrations = @registrations.dup
+        super
+      end
+
       def add_modifier(options, klass, **args)
         registrations << DecorationRegistration.new(options, klass, **args)
       end
 
-      private
-        def registration_klass
-          Registration
+      def register(type_name, klass = nil, **options, &block)
+        unless block_given?
+          block = proc { |_, *args| klass.new(*args) }
+          block.ruby2_keywords if block.respond_to?(:ruby2_keywords)
         end
+        registrations << Registration.new(type_name, block, **options)
+      end
+
+      def lookup(symbol, *args, **kwargs)
+        registration = find_registration(symbol, *args, **kwargs)
+
+        if registration
+          registration.call(self, symbol, *args, **kwargs)
+        else
+          raise ArgumentError, "Unknown type #{symbol.inspect}"
+        end
+      end
+
+      private
+        attr_reader :registrations
 
         def find_registration(symbol, *args, **kwargs)
           registrations
@@ -22,7 +47,7 @@ module ActiveRecord
         end
     end
 
-    class Registration
+    class Registration # :nodoc:
       def initialize(name, block, adapter: nil, override: nil)
         @name = name
         @block = block
@@ -89,7 +114,7 @@ module ActiveRecord
         end
     end
 
-    class DecorationRegistration < Registration
+    class DecorationRegistration < Registration # :nodoc:
       def initialize(options, klass, adapter: nil)
         @options = options
         @klass = klass
@@ -120,7 +145,7 @@ module ActiveRecord
     end
   end
 
-  class TypeConflictError < StandardError
+  class TypeConflictError < StandardError # :nodoc:
   end
   # :startdoc:
 end