activerecord 7.1.4.1 → 7.2.2.1

data/lib/active_record/connection_adapters/trilogy/database_statements.rb

@@ -4,20 +4,12 @@ module ActiveRecord
   module ConnectionAdapters
     module Trilogy
       module DatabaseStatements
-        def select_all(*, **) # :nodoc:
-          result = super
-          with_raw_connection do |conn|
-            conn.next_result while conn.more_results_exist?
-          end
-          result
-        end
-
-        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false) # :nodoc:
+        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false) # :nodoc:
           sql = transform_query(sql)
           check_if_write_query(sql)
           mark_transaction_written_if_write(sql)
 
-          result = raw_execute(sql, name, async: async)
+          result = raw_execute(sql, name, async: async, allow_retry: allow_retry)
           ActiveRecord::Result.new(result.fields, result.to_a)
         end
 
@@ -26,7 +18,8 @@ module ActiveRecord
           check_if_write_query(sql)
           mark_transaction_written_if_write(sql)
 
-          raw_execute(to_sql(sql, binds), name)
+          sql, _binds = sql_for_insert(sql, pk, binds, returning)
+          raw_execute(sql, name)
         end
 
         def exec_delete(sql, name = nil, binds = []) # :nodoc:
@@ -42,19 +35,27 @@ module ActiveRecord
 
         private
           def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
-            log(sql, name, async: async) do
+            log(sql, name, async: async) do |notification_payload|
               with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
                 sync_timezone_changes(conn)
                 result = conn.query(sql)
+                while conn.more_results_exist?
+                  conn.next_result
+                end
                 verified!
                 handle_warnings(sql)
+                notification_payload[:row_count] = result.count
                 result
               end
             end
           end
 
           def last_inserted_id(result)
-            result.last_insert_id
+            if supports_insert_returning?
+              super
+            else
+              result.last_insert_id
+            end
           end
 
           def sync_timezone_changes(conn)
@@ -71,7 +72,6 @@ module ActiveRecord
             combine_multi_statements(statements).each do |statement|
               with_raw_connection do |conn|
                 raw_execute(statement, name)
-                conn.next_result while conn.more_results_exist?
               end
             end
           end
@@ -90,7 +90,7 @@ module ActiveRecord
 
               yield
             ensure
-              conn.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_OFF)
+              conn.set_server_option(::Trilogy::SET_SERVER_MULTI_STATEMENTS_OFF) if active?
             end
           end
       end

data/lib/active_record/connection_adapters/trilogy_adapter.rb

@@ -2,44 +2,17 @@
 
 require "active_record/connection_adapters/abstract_mysql_adapter"
 
-gem "trilogy", "~> 2.4"
+gem "trilogy", "~> 2.7"
 require "trilogy"
 
 require "active_record/connection_adapters/trilogy/database_statements"
 
 module ActiveRecord
-  module ConnectionHandling # :nodoc:
-    def trilogy_adapter_class
-      ConnectionAdapters::TrilogyAdapter
-    end
-
-    # Establishes a connection to the database that's used by all Active Record objects.
-    def trilogy_connection(config)
-      configuration = config.dup
-
-      # Set FOUND_ROWS capability on the connection so UPDATE queries returns number of rows
-      # matched rather than number of rows updated.
-      configuration[:found_rows] = true
-
-      options = [
-        configuration[:host],
-        configuration[:port],
-        configuration[:database],
-        configuration[:username],
-        configuration[:password],
-        configuration[:socket],
-        0
-      ]
-
-      trilogy_adapter_class.new nil, logger, options, configuration
-    end
-  end
   module ConnectionAdapters
     class TrilogyAdapter < AbstractMysqlAdapter
       ER_BAD_DB_ERROR = 1049
       ER_DBACCESS_DENIED_ERROR = 1044
       ER_ACCESS_DENIED_ERROR = 1045
-      ER_SERVER_SHUTDOWN = 1053
 
       ADAPTER_NAME = "Trilogy"
 
@@ -99,16 +72,22 @@ module ActiveRecord
           end
       end
 
-      def initialize(...)
-        super
+      def initialize(config, *)
+        config = config.dup
+
+        # Trilogy ignores `socket` if `host is set. We want the opposite to allow
+        # configuring UNIX domain sockets via `DATABASE_URL`.
+        config.delete(:host) if config[:socket]
 
-        if @config[:prepared_statements]
+        # Set FOUND_ROWS capability on the connection so UPDATE queries returns number of rows
+        # matched rather than number of rows updated.
+        config[:found_rows] = true
+
+        if config[:prepared_statements]
           raise ArgumentError, "Trilogy currently doesn't support prepared statements. Remove `prepared_statements: true` from your database configuration."
         end
 
-        # Trilogy ignore `socket` if `host is set. We want the opposite to allow
-        # configuring UNIX domain sockets via `DATABASE_URL`.
-        @config.delete(:host) if @config[:socket]
+        super
       end
 
       TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
@@ -137,14 +116,12 @@ module ActiveRecord
         true
       end
 
-      def quote_string(string)
-        with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
-          conn.escape(string)
-        end
+      def connected?
+        !(@raw_connection.nil? || @raw_connection.closed?)
       end
 
       def active?
-        !(@raw_connection.nil? || @raw_connection.closed?) && @lock.synchronize { @raw_connection&.ping } || false
+        connected? && @lock.synchronize { @raw_connection&.ping } || false
       rescue ::Trilogy::Error
         false
       end
@@ -206,7 +183,7 @@ module ActiveRecord
         end
 
         def full_version
-          schema_cache.database_version.full_version_string
+          database_version.full_version_string
         end
 
         def get_full_version
@@ -219,18 +196,12 @@ module ActiveRecord
           if exception.is_a?(::Trilogy::TimeoutError) && !exception.error_code
             return ActiveRecord::AdapterTimeout.new(message, sql: sql, binds: binds, connection_pool: @pool)
           end
-          error_code = exception.error_code if exception.respond_to?(:error_code)
-
-          case error_code
-          when ER_SERVER_SHUTDOWN
-            return ConnectionFailed.new(message, connection_pool: @pool)
-          end
 
           case exception
-          when Errno::EPIPE, SocketError, IOError
+          when ::Trilogy::ConnectionClosed, ::Trilogy::EOFError
             return ConnectionFailed.new(message, connection_pool: @pool)
           when ::Trilogy::Error
-            if /Connection reset by peer|TRILOGY_CLOSED_CONNECTION|TRILOGY_INVALID_SEQUENCE_ID|TRILOGY_UNEXPECTED_PACKET/.match?(exception.message)
+            if exception.is_a?(SystemCallError) || exception.message.include?("TRILOGY_INVALID_SEQUENCE_ID")
               return ConnectionFailed.new(message, connection_pool: @pool)
             end
           end

data/lib/active_record/connection_adapters.rb

@@ -1,9 +1,130 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/string/filters"
+
 module ActiveRecord
   module ConnectionAdapters
     extend ActiveSupport::Autoload
 
+    @adapters = {}
+
+    class << self
+      # Registers a custom database adapter.
+      #
+      # Can also be used to define aliases.
+      #
+      # == Example
+      #
+      #   ActiveRecord::ConnectionAdapters.register("megadb", "MegaDB::ActiveRecordAdapter", "mega_db/active_record_adapter")
+      #
+      #   ActiveRecord::ConnectionAdapters.register("mysql", "ActiveRecord::ConnectionAdapters::TrilogyAdapter", "active_record/connection_adapters/trilogy_adapter")
+      #
+      def register(name, class_name, path = class_name.underscore)
+        @adapters[name.to_s] = [class_name, path]
+      end
+
+      def resolve(adapter_name) # :nodoc:
+        # Require the adapter itself and give useful feedback about
+        #   1. Missing adapter gems.
+        #   2. Incorrectly registered adapters.
+        #   3. Adapter gems' missing dependencies.
+        class_name, path_to_adapter = @adapters[adapter_name.to_s]
+
+        unless class_name
+          # To provide better error messages for adapters expecting the pre-7.2 adapter registration API, we attempt
+          # to load the adapter file from the old location which was required by convention, and then raise an error
+          # describing how to upgrade the adapter to the new API.
+          legacy_adapter_path = "active_record/connection_adapters/#{adapter_name}_adapter"
+          legacy_adapter_connection_method_name = "#{adapter_name}_connection".to_sym
+
+          begin
+            require legacy_adapter_path
+            # If we reach here it means we found the found a file that may be the legacy adapter and should raise.
+            if ActiveRecord::ConnectionHandling.method_defined?(legacy_adapter_connection_method_name)
+              # If we find the connection method then we care certain it is a legacy adapter.
+              deprecation_message = <<~MSG.squish
+                Database configuration specifies '#{adapter_name}' adapter but that adapter has not been registered.
+                Rails 7.2 has changed the way Active Record database adapters are loaded. The adapter needs to be
+                updated to register itself rather than being loaded by convention.
+                Ensure that the adapter in the Gemfile is at the latest version. If it is, then the adapter may need to
+                be modified.
+                See:
+                https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters.html#method-c-register
+              MSG
+
+              exception_message = <<~MSG.squish
+                Database configuration specifies '#{adapter_name}' adapter but that adapter has not been registered.
+                Ensure that the adapter in the Gemfile is at the latest version. If it is, then the adapter may need to
+                be modified.
+              MSG
+            else
+              # If we do not find the connection method we are much less certain it is a legacy adapter. Even though the
+              # file exists in the location defined by convenntion, it does not necessarily mean that file is supposed
+              # to define the adapter the legacy way. So raise an error that explains both possibilities.
+              deprecation_message = <<~MSG.squish
+                Database configuration specifies nonexistent '#{adapter_name}' adapter.
+                Available adapters are: #{@adapters.keys.sort.join(", ")}.
+                Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary
+                adapter gem to your Gemfile if it's not in the list of available adapters.
+                Rails 7.2 has changed the way Active Record database adapters are loaded. Ensure that the adapter in
+                the Gemfile is at the latest version. If it is up to date, the adapter may need to be modified.
+                See:
+                https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters.html#method-c-register
+              MSG
+
+              exception_message = <<~MSG.squish
+                Database configuration specifies nonexistent '#{adapter_name}' adapter.
+                Available adapters are: #{@adapters.keys.sort.join(", ")}.
+                Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary
+                adapter gem to your Gemfile and that it is at its latest version. If it is up to date, the adapter may
+                need to be modified.
+              MSG
+            end
+
+            ActiveRecord.deprecator.warn(deprecation_message)
+            raise AdapterNotFound, exception_message
+          rescue LoadError => error
+            # The adapter was not found in the legacy location so fall through to the error handling for a missing adapter.
+          end
+
+          raise AdapterNotFound, <<~MSG.squish
+            Database configuration specifies nonexistent '#{adapter_name}' adapter.
+            Available adapters are: #{@adapters.keys.sort.join(", ")}.
+            Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary
+            adapter gem to your Gemfile if it's not in the list of available adapters.
+          MSG
+        end
+
+        unless Object.const_defined?(class_name)
+          begin
+            require path_to_adapter
+          rescue LoadError => error
+            # We couldn't require the adapter itself.
+            if error.path == path_to_adapter
+              # We can assume here that a non-builtin adapter was specified and the path
+              # registered by the adapter gem is incorrect.
+              raise LoadError, "Error loading the '#{adapter_name}' Active Record adapter. Ensure that the path registered by the adapter gem is correct. #{error.message}", error.backtrace
+            else
+              # Bubbled up from the adapter require. Prefix the exception message
+              # with some guidance about how to address it and reraise.
+              raise LoadError, "Error loading the '#{adapter_name}' Active Record adapter. Missing a gem it depends on? #{error.message}", error.backtrace
+            end
+          end
+        end
+
+        begin
+          Object.const_get(class_name)
+        rescue NameError => error
+          raise AdapterNotFound, "Could not load the #{class_name} Active Record adapter (#{error.message})."
+        end
+      end
+    end
+
+    register "sqlite3", "ActiveRecord::ConnectionAdapters::SQLite3Adapter", "active_record/connection_adapters/sqlite3_adapter"
+    register "mysql2", "ActiveRecord::ConnectionAdapters::Mysql2Adapter", "active_record/connection_adapters/mysql2_adapter"
+    register "trilogy", "ActiveRecord::ConnectionAdapters::TrilogyAdapter", "active_record/connection_adapters/trilogy_adapter"
+    register "postgresql", "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter", "active_record/connection_adapters/postgresql_adapter"
+
     eager_autoload do
       autoload :AbstractAdapter
     end

data/lib/active_record/connection_handling.rb

@@ -243,22 +243,64 @@ module ActiveRecord
     # Clears the query cache for all connections associated with the current thread.
     def clear_query_caches_for_current_thread
       connection_handler.each_connection_pool do |pool|
-        pool.connection.clear_query_cache if pool.active_connection?
+        pool.clear_query_cache
       end
     end
 
     # Returns the connection currently associated with the class. This can
     # also be used to "borrow" the connection to do database work unrelated
     # to any of the specific Active Records.
+    # The connection will remain leased for the entire duration of the request
+    # or job, or until +#release_connection+ is called.
+    def lease_connection
+      connection_pool.lease_connection
+    end
+
+    # Soft deprecated. Use +#with_connection+ or +#lease_connection+ instead.
     def connection
-      retrieve_connection
+      pool = connection_pool
+      if pool.permanent_lease?
+        case ActiveRecord.permanent_connection_checkout
+        when :deprecated
+          ActiveRecord.deprecator.warn <<~MESSAGE
+            Called deprecated `ActiveRecord::Base.connection` method.
+
+            Either use `with_connection` or `lease_connection`.
+          MESSAGE
+        when :disallowed
+          raise ActiveRecordError, <<~MESSAGE
+            Called deprecated `ActiveRecord::Base.connection` method.
+
+            Either use `with_connection` or `lease_connection`.
+          MESSAGE
+        end
+        pool.lease_connection
+      else
+        pool.active_connection
+      end
+    end
+
+    # Return the currently leased connection into the pool
+    def release_connection
+      connection_pool.release_connection
+    end
+
+    # Checkouts a connection from the pool, yield it and then check it back in.
+    # If a connection was already leased via #lease_connection or a parent call to
+    # #with_connection, that same connection is yieled.
+    # If #lease_connection is called inside the block, the connection won't be checked
+    # back in.
+    # If #connection is called inside the block, the connection won't be checked back in
+    # unless the +prevent_permanent_checkout+ argument is set to +true+.
+    def with_connection(prevent_permanent_checkout: false, &block)
+      connection_pool.with_connection(prevent_permanent_checkout: prevent_permanent_checkout, &block)
     end
 
     attr_writer :connection_specification_name
 
     # Returns the connection specification name from the current class or its parent.
     def connection_specification_name
-      if !defined?(@connection_specification_name) || @connection_specification_name.nil?
+      if @connection_specification_name.nil?
         return self == Base ? Base.name : superclass.connection_specification_name
       end
       @connection_specification_name
@@ -279,8 +321,12 @@ module ActiveRecord
       connection_pool.db_config
     end
 
+    def adapter_class # :nodoc:
+      connection_pool.db_config.adapter_class
+    end
+
     def connection_pool
-      connection_handler.retrieve_connection_pool(connection_specification_name, role: current_role, shard: current_shard) || raise(ConnectionNotEstablished)
+      connection_handler.retrieve_connection_pool(connection_specification_name, role: current_role, shard: current_shard, strict: true)
     end
 
     def retrieve_connection
@@ -292,16 +338,9 @@ module ActiveRecord
       connection_handler.connected?(connection_specification_name, role: current_role, shard: current_shard)
     end
 
-    def remove_connection(name = nil)
-      if name
-        ActiveRecord.deprecator.warn(<<-MSG.squish)
-          The name argument for `#remove_connection` is deprecated without replacement
-          and will be removed in Rails 7.2. `#remove_connection` should always be called
-          on the connection class directly, which makes the name argument obsolete.
-        MSG
-      end
+    def remove_connection
+      name = @connection_specification_name if defined?(@connection_specification_name)
 
-      name ||= @connection_specification_name if defined?(@connection_specification_name)
       # if removing a connection that has a pool, we reset the
       # connection_specification_name so it will use the parent
       # pool.
@@ -312,39 +351,15 @@ module ActiveRecord
       connection_handler.remove_connection_pool(name, role: current_role, shard: current_shard)
     end
 
-    def clear_cache! # :nodoc:
-      connection.schema_cache.clear!
-    end
-
-    def clear_active_connections!(role = nil)
-      deprecation_for_delegation(__method__)
-      connection_handler.clear_active_connections!(role)
-    end
-
-    def clear_reloadable_connections!(role = nil)
-      deprecation_for_delegation(__method__)
-      connection_handler.clear_reloadable_connections!(role)
+    def schema_cache # :nodoc:
+      connection_pool.schema_cache
     end
 
-    def clear_all_connections!(role = nil)
-      deprecation_for_delegation(__method__)
-      connection_handler.clear_all_connections!(role)
-    end
-
-    def flush_idle_connections!(role = nil)
-      deprecation_for_delegation(__method__)
-      connection_handler.flush_idle_connections!(role)
+    def clear_cache! # :nodoc:
+      connection_pool.schema_cache.clear!
     end
 
     private
-      def deprecation_for_delegation(method)
-        ActiveRecord.deprecator.warn(<<-MSG.squish)
-          Calling `ActiveRecord::Base.#{method} is deprecated. Please
-          call the method directly on the connection handler; for
-          example: `ActiveRecord::Base.connection_handler.#{method}`.
-        MSG
-      end
-
       def resolve_config_for_connection(config_or_env)
         raise "Anonymous class is not allowed." unless name
 

data/lib/active_record/core.rb

@@ -73,7 +73,7 @@ module ActiveRecord
       end
       self.configurations = {}
 
-      # Returns fully resolved ActiveRecord::DatabaseConfigurations object
+      # Returns a fully resolved ActiveRecord::DatabaseConfigurations object.
       def self.configurations
         @@configurations
       end
@@ -102,6 +102,21 @@ module ActiveRecord
 
       class_attribute :shard_selector, instance_accessor: false, default: nil
 
+      ##
+      # :singleton-method:
+      #
+      # Specifies the attributes that will be included in the output of the
+      # #inspect method:
+      #
+      #   Post.attributes_for_inspect = [:id, :title]
+      #   Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!">"
+      #
+      # When set to `:all` inspect will list all the record's attributes:
+      #
+      #   Post.attributes_for_inspect = :all
+      #   Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
+      class_attribute :attributes_for_inspect, instance_accessor: false, default: :all
+
       def self.application_record_class? # :nodoc:
         if ActiveRecord.application_record_class
           self == ActiveRecord.application_record_class
@@ -346,12 +361,12 @@ module ActiveRecord
 
       # Returns a string like 'Post(id:integer, title:string, body:text)'
       def inspect # :nodoc:
-        if self == Base
+        if self == Base || singleton_class?
           super
         elsif abstract_class?
           "#{super}(abstract)"
-        elsif !connected?
-          "#{super} (call '#{super}.connection' to establish a connection)"
+        elsif !schema_loaded? && !connected?
+          "#{super} (call '#{super}.load_schema' to load schema informations)"
         elsif table_exists?
           attr_list = attribute_types.map { |name, type| "#{name}: #{type.type}" } * ", "
           "#{super}(#{attr_list})"
@@ -373,7 +388,7 @@ module ActiveRecord
         TypeCaster::Map.new(self)
       end
 
-      def cached_find_by_statement(key, &block) # :nodoc:
+      def cached_find_by_statement(connection, key, &block) # :nodoc:
         cache = @find_by_statement_cache[connection.prepared_statements]
         cache.compute_if_absent(key) { StatementCache.create(connection, &block) }
       end
@@ -416,21 +431,23 @@ module ActiveRecord
         end
 
         def cached_find_by(keys, values)
-          statement = cached_find_by_statement(keys) { |params|
-            wheres = keys.index_with do |key|
-              if key.is_a?(Array)
-                [key.map { params.bind }]
-              else
-                params.bind
+          with_connection do |connection|
+            statement = cached_find_by_statement(connection, keys) { |params|
+              wheres = keys.index_with do |key|
+                if key.is_a?(Array)
+                  [key.map { params.bind }]
+                else
+                  params.bind
+                end
               end
-            end
-            where(wheres).limit(1)
-          }
+              where(wheres).limit(1)
+            }
 
-          begin
-            statement.execute(values.flatten, connection).first
-          rescue TypeError
-            raise ActiveRecord::StatementInvalid
+            begin
+              statement.execute(values.flatten, connection, allow_retry: true).first
+            rescue TypeError
+              raise ActiveRecord::StatementInvalid
+            end
           end
         end
     end
@@ -450,7 +467,7 @@ module ActiveRecord
       init_internals
       initialize_internals_callback
 
-      assign_attributes(attributes) if attributes
+      super
 
       yield self if block_given?
       _run_initialize_callbacks
@@ -719,21 +736,28 @@ module ActiveRecord
       self.class.connection_handler
     end
 
-    # Returns the contents of the record as a nicely formatted string.
+    # Returns the attributes of the record as a nicely formatted string.
+    #
+    #   Post.first.inspect
+    #   #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
+    #
+    # The attributes can be limited by setting <tt>.attributes_for_inspect</tt>.
+    #
+    #   Post.attributes_for_inspect = [:id, :title]
+    #   Post.first.inspect
+    #   #=> "#<Post id: 1, title: "Hello, World!">"
     def inspect
-      # We check defined?(@attributes) not to issue warnings if the object is
-      # allocated but not initialized.
-      inspection = if defined?(@attributes) && @attributes
-        attribute_names.filter_map do |name|
-          if _has_attribute?(name)
-            "#{name}: #{attribute_for_inspect(name)}"
-          end
-        end.join(", ")
-      else
-        "not initialized"
-      end
+      inspect_with_attributes(attributes_for_inspect)
+    end
 
-      "#<#{self.class} #{inspection}>"
+    # Returns all attributes of the record as a nicely formatted string,
+    # ignoring <tt>.attributes_for_inspect</tt>.
+    #
+    #   Post.first.full_inspect
+    #   #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
+    #
+    def full_inspect
+      inspect_with_attributes(all_attributes_for_inspect)
     end
 
     # Takes a PP and prettily prints this record to it, allowing you to get a nice result from <tt>pp record</tt>
@@ -741,17 +765,17 @@ module ActiveRecord
     def pretty_print(pp)
       return super if custom_inspect_method_defined?
       pp.object_address_group(self) do
-        if defined?(@attributes) && @attributes
-          attr_names = self.class.attribute_names.select { |name| _has_attribute?(name) }
+        if @attributes
+          attr_names = attributes_for_inspect.select { |name| _has_attribute?(name.to_s) }
           pp.seplist(attr_names, proc { pp.text "," }) do |attr_name|
+            attr_name = attr_name.to_s
             pp.breakable " "
             pp.group(1) do
               pp.text attr_name
               pp.text ":"
               pp.breakable
-              value = _read_attribute(attr_name)
-              value = inspection_filter.filter_param(attr_name, value) unless value.nil?
-              pp.pp value
+              value = attribute_for_inspect(attr_name)
+              pp.text value
             end
           end
         else
@@ -789,7 +813,6 @@ module ActiveRecord
         @strict_loading_mode = :all
 
         klass.define_attribute_methods
-        klass.generate_alias_attributes
       end
 
       def initialize_internals_callback
@@ -809,5 +832,30 @@ module ActiveRecord
       def inspection_filter
         self.class.inspection_filter
       end
+
+      def inspect_with_attributes(attributes_to_list)
+        inspection = if @attributes
+          attributes_to_list.filter_map do |name|
+            name = name.to_s
+            if _has_attribute?(name)
+              "#{name}: #{attribute_for_inspect(name)}"
+            end
+          end.join(", ")
+        else
+          "not initialized"
+        end
+
+        "#<#{self.class} #{inspection}>"
+      end
+
+      def attributes_for_inspect
+        self.class.attributes_for_inspect == :all ? all_attributes_for_inspect : self.class.attributes_for_inspect
+      end
+
+      def all_attributes_for_inspect
+        return [] unless @attributes
+
+        attribute_names
+      end
   end
 end