neo4j-ruby-driver 4.4.0.alpha.6 → 4.4.0.alpha.7

data/ruby/neo4j/driver/internal/cluster/routing_table_registry_impl.rb

@@ -2,78 +2,57 @@ module Neo4j::Driver
   module Internal
     module Cluster
       class RoutingTableRegistryImpl
-        def initialize(connection_pool, rediscovery, clock, logger, routing_table_purge_delay_ms)
-          @factory = RoutingTableHandlerFactory.new(connection_pool, rediscovery, clock, logger, routing_table_purge_delay_ms)
-          @routing_table_handlers = Concurrent::Hash.new
-          @principal_to_database_name_stage = {}
+        def initialize(connection_pool, rediscovery, clock, logger, routing_table_purge_delay)
+          @factory = RoutingTableHandlerFactory.new(connection_pool, rediscovery, clock, logger, routing_table_purge_delay)
+          @routing_table_handlers = Concurrent::Map.new
+          @principal_to_database_name = {}
           @clock = clock
           @connection_pool = connection_pool
           @rediscovery = rediscovery
           @log = logger
+          @mutex = Mutex.new
         end
 
         def ensure_routing_table(context)
-          ensure_database_name_is_completed(context).then_compose do |ctx_and_handler|
-            completed_context = ctx_and_handler.context
-            handler = ctx_and_handler.handler.nil? ? get_or_create(Util::Futures.join_now_or_else_throw(completed_context.database_name_future, Async::ConnectionContext::PENDING_DATABASE_NAME_EXCEPTION_SUPPLIER)) : ctx_and_handler.handler
-            handler.ensure_routing_table(completed_context).then_apply(-> (_ignored) { handler })
-          end
+          ctx_and_handler = ensure_database_name_is_completed(context)
+          (ctx_and_handler.handler || get_or_create(context.database_name))
+            .tap { |handler| handler.ensure_routing_table(ctx_and_handler.context) }
         end
 
         private def ensure_database_name_is_completed(context)
-          context_database_name_future = context.database_name_future
+          context_database_name = context.database_name
+
+          return ConnectionContextAndHandler.new(context, nil) if context_database_name
+          @mutex.synchronize do
+            return ConnectionContextAndHandler.new(context, nil) if context_database_name
 
-          if context_database_name_future.done?
-            context_and_handler_stage = java.util.concurrent.CompletableFuture.completed_future(ConnectionContextAndHandler.new(context, nil))
-          else
             impersonated_user = context.impersonated_user
             principal = Principal.new(impersonated_user)
-            database_name_stage = @principal_to_database_name_stage[principal]
-            handler_ref = java.util.concurrent.atomic.AtomicReference.new
-
-            if database_name_stage.nil?
-              database_name_future = java.util.concurrent.CompletableFuture.new
-              @principal_to_database_name_stage[principal] = database_name_future
-              database_name_stage = database_name_future
-
-              routing_table = ClusterRoutingTable.new(DatabaseNameUtil::DEFAULT_DATABASE, @clock)
-
-              @rediscovery.lookup_cluster_composition(routing_table, @connection_pool, context.rediscovery_bookmark, impersonated_user).then_compose do |composition_lookup_result|
-                database_name = DatabaseNameUtil.database(composition_lookup_result.cluster_composition.database_name)
-                handler = get_or_create(database_name)
-                handler_ref.set(handler)
-                handler.update_routing_table(composition_lookup_result).then_apply(-> (_ignored) { database_name })
-              end.when_complete do |database_name, _throwable|
-                    @principal_to_database_name_stage.delete(principal)
-                  end.when_complete do |database_name, throwable|
-                        if throwable.nil?
-                          database_name_future.complete(database_name)
-                        else
-                          database_name_future.complete_exceptionally(throwable)
-                        end
-                      end
-            end
+            database_name = @principal_to_database_name[principal]
+            handler_ref = Concurrent::AtomicReference.new
 
-            context_and_handler_stage =
-            database_name_stage.then_apply do |database_name|
-              context_database_name_future.complete(database_name)
-              ConnectionContextAndHandler.new(context, handler_ref)
+            if database_name.nil?
+              @principal_to_database_name[principal] = database_name
+
+              routing_table = ClusterRoutingTable.new(DatabaseNameUtil.default_database, @clock)
+
+              composition_lookup_result = @rediscovery.lookup_cluster_composition(routing_table, @connection_pool, context.rediscovery_bookmark, impersonated_user)
+              database_name = DatabaseNameUtil.database(composition_lookup_result.cluster_composition.database_name)
+              handler = get_or_create(database_name)
+              handler_ref.set(handler)
+              handler.update_routing_table(composition_lookup_result)
+              @principal_to_database_name.delete(principal)
             end
-          end
 
-          context_and_handler_stage
+            context.database_name = database_name
+            ConnectionContextAndHandler.new(context, handler_ref.get)
+          end
         end
 
         def all_servers
           # obviously we just had a snapshot of all servers in all routing tables
           # after we read it, the set could already be changed.
-          servers = []
-
-          @routing_table_handlers.values.each do |table_handler|
-            servers << table_handler.servers
-          end
-
-          servers
+          @routing_table_handlers.values.map(&:servers).reduce(&:+)
         end
 
         def remove(database_name)
@@ -90,17 +69,19 @@ module Neo4j::Driver
           end
         end
 
-        def get_routing_table_handler(database_name)
-          java.util.Optional.of_nullable(@routing_table_handlers[database_name])
+        def routing_table_handler(database_name)
+          database_name = DatabaseNameUtil.database(database_name) unless database_name.is_a?(InternalDatabaseName)
+          @routing_table_handlers[database_name]
         end
 
-        def contains(database_name)
-          @routing_table_handlers.keys.include?(database_name)
-        end
+        # For tests
+        delegate :key?, to: :@routing_table_handlers
 
         def get_or_create(database_name)
-          @routing_table_handlers.compute_if_absent(database_name) do |name|
-            handler = @factory.new_instance(name, self)
+          @routing_table_handlers.compute_if_absent(database_name) do
+            # TODO: Verify if applies
+            # Note: Atomic methods taking a block do not allow the self instance to be used within the block. Doing so will cause a deadlock.
+            handler = @factory.new_instance(database_name, self)
             @log.debug("Routing table handler for database '#{database_name.description}' is added.")
             handler
           end
@@ -109,17 +90,17 @@ module Neo4j::Driver
         private
 
         class RoutingTableHandlerFactory
-          def initialize(connection_pool, rediscovery, clock, logger, routing_table_purge_delay_ms)
+          def initialize(connection_pool, rediscovery, clock, logger, routing_table_purge_delay)
             @connection_pool = connection_pool
             @rediscovery = rediscovery
             @clock = clock
             @logger = logger
-            @routing_table_purge_delay_ms = routing_table_purge_delay_ms
+            @routing_table_purge_delay = routing_table_purge_delay
           end
 
           def new_instance(database_name, all_tables)
             routing_table = ClusterRoutingTable.new(database_name, @clock)
-            RoutingTableHandlerImpl.new(routing_table, @rediscovery, @connection_pool, all_tables, @logger, @routing_table_purge_delay_ms)
+            RoutingTableHandlerImpl.new(routing_table, @rediscovery, @connection_pool, all_tables, @logger, @routing_table_purge_delay)
           end
         end
 

data/ruby/neo4j/driver/internal/cluster/single_database_routing_procedure_runner.rb

@@ -5,7 +5,7 @@ module Neo4j::Driver
       # This implementation of the {@link RoutingProcedureRunner} works with single database versions of Neo4j calling
       # the procedure `dbms.cluster.routing.getRoutingTable`
       class SingleDatabaseRoutingProcedureRunner
-        ROUTING_CONTEXT = 'context'
+        ROUTING_CONTEXT = :context
         GET_ROUTING_TABLE = "CALL dbms.cluster.routing.getRoutingTable($#{ROUTING_CONTEXT})"
 
         def initialize(context)
@@ -16,17 +16,15 @@ module Neo4j::Driver
           delegate = connection(connection)
           procedure = procedure_query(connection.server_version, database_name)
           bookmark_holder = bookmark_holder(bookmark)
-          run_procedure(delegate, procedure, bookmark_holder).then_compose do |records|
-            release_connection(delegate, records).handle do |records, error|
-              process_procedure_response(procedure, records, error)
-            end
-          end
+          records = run_procedure(delegate, procedure, bookmark_holder)
+          release_connection(delegate)
+          process_procedure_response(procedure, records, error)
         end
 
         private
 
         def connection(connection)
-          Async::Connection::DirectConnection.new(connection, default_database, AccessMode::WRITE, nil)
+          Async::Connection::DirectConnection.new(connection, DatabaseNameUtil.default_database, AccessMode::WRITE, nil)
         end
 
         def procedure_query(server_version, database_name)
@@ -45,16 +43,16 @@ module Neo4j::Driver
           connection.protocol
                     .run_in_auto_commit_transaction(connection, procedure, bookmark_holder, TransactionConfig.empty,
                                                     Handlers::Pulln::FetchSizeUtil::UNLIMITED_FETCH_SIZE)
-                    .async_result.then_compose(Async::ResultCursor::list_async)
+                    .async_result.to_a
         end
 
-        def release_connection(connection, records)
+        def release_connection(connection)
           # It is not strictly required to release connection after routing procedure invocation because it'll
           # be released by the PULL_ALL response handler after result is fully fetched. Such release will happen
           # in background. However, releasing it early as part of whole chain makes it easier to reason about
           # rediscovery in stub server tests. Some of them assume connections to instances not present in new
           # routing table will be closed immediately.
-          connection.release.then_apply(->(_ignore) { records } )
+          connection.release
         end
 
         def process_procedure_response(procedure, records, error)

data/ruby/neo4j/driver/internal/cursor/async_result_cursor_impl.rb

@@ -2,6 +2,7 @@ module Neo4j::Driver
   module Internal
     module Cursor
       class AsyncResultCursorImpl
+        include Enumerable
         delegate :consume_async, :next_async, :peek_async, to: :@pull_all_handler
 
         def initialize(run_handler, pull_all_handler)
@@ -25,7 +26,7 @@ module Neo4j::Driver
           first_record
         end
 
-        def each_async(&action)
+        def each(&action)
           internal_for_each_async(&action)
           consume_async
         end

data/ruby/neo4j/driver/internal/cursor/disposable_async_result_cursor.rb

@@ -2,6 +2,7 @@ module Neo4j::Driver
   module Internal
     module Cursor
       class DisposableAsyncResultCursor
+        include Enumerable
         delegate :keys, :pull_all_failure_async, to: :@delegate
 
         def initialize(delegate)
@@ -14,25 +15,23 @@ module Neo4j::Driver
         end
 
         def next_async
-          assert_not_disposed.then_compose(-> (_ignored) { @delegate.next_async })
+          assert_not_disposed
+          @delegate.next_async
         end
 
         def peek_async
-          assert_not_disposed.then_compose(-> (_ignored) { @delegate.peek_async })
+          assert_not_disposed
+          @delegate.peek_async
         end
 
         def single_async
-          assert_not_disposed.then_compose(-> (_ignored) { @delegate.single_async })
+          assert_not_disposed
+          @delegate.single_async
         end
 
-        def for_each_async(action)
-          assert_not_disposed.then_compose(-> (_ignored) { @delegate.for_each_async(action) })
-        end
-
-        def list_async(map_function = nil)
-          return assert_not_disposed.then_compose(-> (_ignored) { @delegate.list_async(map_function) }) if map_function.present?
-
-          assert_not_disposed.then_compose(-> (_ignored) { @delegate.list_async })
+        def each(&action)
+          assert_not_disposed
+          @delegate.each(&action)
         end
 
         def discard_all_failure_async
@@ -41,9 +40,7 @@ module Neo4j::Driver
         end
 
         private def assert_not_disposed
-          return Util::Futures.failed_future(new_result_consumed_error) if @disposed
-
-          Util::Futures.completed_with_null
+          raise Neo4j::Driver::Internal::Util.new_result_consumed_error if @disposed
         end
 
         def disposed?

data/ruby/neo4j/driver/internal/database_name_util.rb

@@ -6,8 +6,8 @@ module Neo4j::Driver
 
       private
 
-      DEFAULT_DATABASE = Struct.new(:database_name, :description).new(nil, '<default database>')
-      SYSTEM_DATABASE = InternalDatabaseName.new(SYSTEM_DATABASE_NAME)
+      DEFAULT_DATABASE = InternalDatabaseName.new(description: '<default database>')
+      SYSTEM_DATABASE = InternalDatabaseName.new(database_name: SYSTEM_DATABASE_NAME)
 
       public
 
@@ -27,7 +27,7 @@ module Neo4j::Driver
           when SYSTEM_DATABASE_NAME
             system_database
           else
-            InternalDatabaseName.new(name)
+            InternalDatabaseName.new(database_name: name)
           end
         end
       end

data/ruby/neo4j/driver/internal/default_bookmark_holder.rb

@@ -1,12 +1,6 @@
 module Neo4j::Driver
   module Internal
-    class DefaultBookmarkHolder
-      attr_reader :bookmark
-
-      def initialize(bookmark = InternalBookmark.empty)
-        @bookmark = bookmark
-      end
-
+    class DefaultBookmarkHolder < ReadOnlyBookmarkHolder
       def bookmark=(bookmark)
         @bookmark = bookmark if bookmark.present?
       end

data/ruby/neo4j/driver/internal/direct_connection_provider.rb

@@ -22,7 +22,7 @@ module Neo4j::Driver
 
       def supports_multi_db?
         private_acquire_connection.then do |conn|
-          supports_multi_database?(conn)
+          Messaging::Request::MultiDatabaseUtil.supports_multi_database?(conn)
         ensure
           conn.release
         end

data/ruby/neo4j/driver/internal/driver_factory.rb

@@ -83,8 +83,8 @@ module Neo4j::Driver::Internal
       driver(:Direct, securityPlan, address, connection_provider, retryLogic, metricsProvider, config)
     end
 
-    def create_routing_driver(securityPlan, address, connection_pool, eventExecutorGroup, routingSettings, retryLogic, metricsProvider, config)
-      connection_provider = create_load_balancer(address, connection_pool, eventExecutorGroup, config, routingSettings)
+    def create_routing_driver(securityPlan, address, connection_pool, eventExecutorGroup, routing_settings, retryLogic, metricsProvider, config)
+      connection_provider = create_load_balancer(address, connection_pool, eventExecutorGroup, config, routing_settings)
       driver(:Routing, securityPlan, address, connection_provider, retryLogic, metricsProvider, config)
     end
 
@@ -95,11 +95,11 @@ module Neo4j::Driver::Internal
       end
     end
 
-    def create_load_balancer(address, connection_pool, eventExecutorGroup, config, routingSettings)
+    def create_load_balancer(address, connection_pool, eventExecutorGroup, config, routing_settings)
       load_balancing_strategy = Cluster::Loadbalancing::LeastConnectedLoadBalancingStrategy.new(connection_pool, config[:logger])
       resolver = create_resolver(config)
       Cluster::Loadbalancing::LoadBalancer.new(
-        address, routingSettings, connection_pool, eventExecutorGroup,
+        address, routing_settings, connection_pool, eventExecutorGroup,
         config[:logger], load_balancing_strategy, resolver, &method(:domain_name_resolver))
     end
 

data/ruby/neo4j/driver/internal/handlers/legacy_pull_all_response_handler.rb

@@ -4,7 +4,6 @@ module Neo4j::Driver
       # This is the Pull All response handler that handles pull all messages in Bolt v3 and previous protocol versions.
       class LegacyPullAllResponseHandler
         include Spi::ResponseHandler
-        UNINITIALIZED_RECORDS = []
         RECORD_BUFFER_LOW_WATERMARK = ENV['record_buffer_low_watermark']&.to_i || 300
         RECORD_BUFFER_HIGH_WATERMARK = ENV['record_buffer_high_watermark']&.to_i || 1000
 
@@ -14,7 +13,7 @@ module Neo4j::Driver
           @metadata_extractor = Internal::Validator.require_non_nil!(metadata_extractor)
           @connection = Internal::Validator.require_non_nil!(connection)
           @completion_listener = Internal::Validator.require_non_nil!(completion_listener)
-          @records = UNINITIALIZED_RECORDS
+          @records = ::Async::Queue.new
         end
 
         def can_manage_auto_read?
@@ -39,7 +38,7 @@ module Neo4j::Driver
 
           failed_record_future = fail_record_future(error)
 
-          if fail_record_future
+          if failed_record_future
             # error propagated through the record future
             complete_failure_future(nil)
           else
@@ -54,7 +53,7 @@ module Neo4j::Driver
           if @ignore_records
             complete_record_future(nil)
           else
-            record = InternalRecord.new(run_response_handler.query_keys, fields)
+            record = InternalRecord.new(@run_response_handler.query_keys, fields)
             enqueue_record(record)
             complete_record_future(record)
           end
@@ -65,36 +64,46 @@ module Neo4j::Driver
         end
 
         def peek_async
-          record = @records.first
+          while @records.empty? && !(@ignore_records || @finished)
+            @records.wait
+          end
+          @records.items.first
 
-          if record.nil?
-            return Util::Futures.failed_future(extract_failure) unless @failure.nil?
+          # if record.nil?
+          #   return Util::Futures.failed_future(extract_failure) unless @failure.nil?
 
-            return Util::Futures.completed_with_null if @ignore_records || @finished
+          #   return Util::Futures.completed_with_null if @ignore_records || @finished
 
-            @record_future = java.util.concurrent.CompletableFuture.new if @record_future.nil?
+          #   @record_future = java.util.concurrent.CompletableFuture.new if @record_future.nil?
 
-            @record_future
-          else
-            java.util.concurrent.CompletableFuture.completed_future(record)
-          end
+          #   @record_future
+          # else
+          #   # java.util.concurrent.CompletableFuture.completed_future(record)
+          #   record
+          # end
         end
 
         def next_async
-          peek_async.then_apply(-> (_ignore) { dequeue_record })
+          dequeue_record if peek_async
         end
 
         def consume_async
           @ignore_records = true
-          @records.clear
-
-          pull_all_failure_async.then_apply do |error|
-            unless error.nil?
-              raise Util::Futures.as_completion_exception, error
-            end
+          @records.items.clear
 
+          if pull_all_failure_async.nil?
             @summary
+          else
+            raise Util::Futures.as_completion_exception, pull_all_failure_async
           end
+
+          # pull_all_failure_async do |error|
+          #   unless error.nil?
+          #     raise Util::Futures.as_completion_exception, error
+          #   end
+
+          #   @summary
+          # end
         end
 
         def list_async(map_function)
@@ -115,7 +124,8 @@ module Neo4j::Driver
           if !@failure.nil?
             return java.util.concurrent.CompletableFuture.completed_future(extract_failure)
           elsif @finished
-            return Util::Futures.completed_with_null
+            return nil
+            # return Util::Futures.completed_with_null
           else
             if @failure_future.nil?
               # neither SUCCESS nor FAILURE message has arrived, register future to be notified when it arrives
@@ -139,7 +149,7 @@ module Neo4j::Driver
           # when failure is requested we have to buffer all remaining records and then return the error
           # do not disable auto-read in this case, otherwise records will not be consumed and trailing
           # SUCCESS or FAILURE message will not arrive as well, so callers will get stuck waiting for the error
-          if !should_buffer_all_records && records.size > RECORD_BUFFER_HIGH_WATERMARK
+          if !should_buffer_all_records && @records.size > RECORD_BUFFER_HIGH_WATERMARK
             # more than high watermark records are already queued, tell connection to stop auto-reading from network
             # this is needed to deal with slow consumers, we do not want to buffer all records in memory if they are
             # fetched from network faster than consumed
@@ -148,7 +158,7 @@ module Neo4j::Driver
         end
 
         def dequeue_record
-          record = @records.drop(1)
+          record = @records.dequeue
 
           if @records.size < RECORD_BUFFER_LOW_WATERMARK
             # less than low watermark records are now available in the buffer, tell connection to pre-fetch more
@@ -170,7 +180,7 @@ module Neo4j::Driver
             result << map_function.apply(record)
           end
 
-          @records.clear
+          @records.items.clear
           result
         end
 

data/ruby/neo4j/driver/internal/impersonation_util.rb

@@ -14,8 +14,8 @@ module Neo4j::Driver
       private
 
       def self.supports_impersonation?(connection)
-        connection.server_version.greater_than_or_equal(Util::ServerVersion::V4_4_0) &&
-        connection.protocol.version.compare_to( Messaging::V44::BoltProtocolV44::VERSION ) >= 0
+        connection.server_version >= Util::ServerVersion::V4_4_0 &&
+          connection.protocol.version >= Messaging::V44::BoltProtocolV44::VERSION
       end
     end
   end

data/ruby/neo4j/driver/internal/internal_bookmark.rb

@@ -2,13 +2,13 @@ module Neo4j::Driver
   module Internal
     class InternalBookmark
       include Bookmark
-      EMPTY = new
       attr :values
       delegate :hash, :empty?, to: :values
 
       private def initialize(*values)
         @values = values.to_set
       end
+      EMPTY = new.freeze
 
       def ==(other)
         equal?(other) || self.class == other.class && values == other.values

data/ruby/neo4j/driver/internal/internal_database_name.rb

@@ -1,10 +1,8 @@
 module Neo4j::Driver
   module Internal
-    class InternalDatabaseName < Struct.new(:database_name)
-      alias description database_name
-
-      def initialize(database_name)
-        super(Validator.require_non_nil!(database_name))
+    class InternalDatabaseName < Struct.new(:database_name, :description)
+      def initialize(database_name: nil, description: database_name)
+        super(database_name, description)
       end
     end
   end

data/ruby/neo4j/driver/internal/messaging/bolt_protocol_version.rb

@@ -2,10 +2,12 @@ module Neo4j::Driver
   module Internal
     module Messaging
       class BoltProtocolVersion < Struct.new(:major_version, :minor_version)
+        include Comparable
+
         def self.from_raw_bytes(raw_version)
           major = raw_version & 0x000000FF
           minor = (raw_version >> 8) & 0x000000FF
-          new(major,minor)
+          new(major, minor)
         end
 
         def to_int

data/ruby/neo4j/driver/internal/messaging/encode/route_message_encoder.rb

@@ -8,8 +8,14 @@ module Neo4j::Driver
             Util::Preconditions.check_argument(message, Request::RouteMessage)
             packer.pack_struct_header(3, message.signature)
             packer.pack(message.routing_context)
-            packer.pack(message.bookmark.present? ? Values.value(message.bookmark.values) : Values.value(java.util.Collections.empty_list))
-            packer.pack(message.database_name)
+            packer.pack(message.bookmark&.values || [])
+            packer.pack(option(message))
+          end
+
+          private
+
+          def option(message)
+            message.database_name
           end
         end
       end

data/ruby/neo4j/driver/internal/messaging/encode/route_v44_message_encoder.rb

@@ -3,22 +3,17 @@ module Neo4j::Driver
     module Messaging
       module Encode
         # Encodes the ROUTE message to the stream
-        class RouteV44MessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::RouteMessage)
-            packer.pack_struct_header(3, message.signature)
-            packer.pack(message.routing_context)
-            packer.pack(message.bookmark.present? ? Values.value(message.bookmark.values) : Values.value(java.util.Collections.empty_list))
+        class RouteV44MessageEncoder < RouteMessageEncoder
+          private
 
-            if !message.impersonated_user.nil? && message.database_name.nil?
-              params = java.util.Collections.singleton_map("imp_user", Values.value(message.impersonated_user))
-            elsif !message.database_name.nil?
-              params = java.util.Collections.singleton_map("db", Values.value(message.database_name))
+          def option(message)
+            if message.impersonated_user && !message.database_name
+              { imp_user: message.impersonated_user }
+            elsif message.database_name
+              { db: message.database_name }
             else
-              params = java.util.Collections.empty_map
+              {}
             end
-
-            packer.pack(params)
           end
         end
       end

data/ruby/neo4j/driver/internal/messaging/request/begin_message.rb

@@ -7,9 +7,8 @@ module Neo4j::Driver
 
           def initialize(bookmark, config, database_name, mode, impersonated_user)
             super(Request::TransactionMetadataBuilder.build_metadata(
-              tx_timeout: config[:timeout]&.then(&DurationNormalizer.method(:milliseconds)),
-              tx_metadata: config[:metadata], database_name: database_name, mode: mode, bookmark: bookmark,
-              impersonated_user: impersonated_user))
+              timeout: config[:timeout], tx_metadata: config[:metadata], database_name: database_name, mode: mode,
+              bookmark: bookmark, impersonated_user: impersonated_user))
           end
 
           def signature

data/ruby/neo4j/driver/internal/messaging/request/multi_database_util.rb

@@ -10,12 +10,12 @@ module Neo4j::Driver
               end
             end
 
-            def supports_multi_database(connection)
+            def supports_multi_database?(connection)
               connection.server_version >= Util::ServerVersion::V4_0_0 &&
                 connection.protocol.version >= V4::BoltProtocolV4::VERSION
             end
 
-            def supports_route_message(connection)
+            def supports_route_message?(connection)
               connection.protocol.version >= V43::BoltProtocolV43::VERSION
             end
           end

data/ruby/neo4j/driver/internal/messaging/request/route_message.rb

@@ -6,19 +6,14 @@ module Neo4j::Driver
         # instance can provide the wanted service.
         # <p>
         # This message is used to fetch this routing information.
+        #
+        # @param routingContext   The routing context used to define the routing table. Multi-datacenter deployments is one of its use cases.
+        # @param bookmark         The bookmark used when getting the routing table.
+        # @param databaseName     The name of the database to get the routing table for.
+        # @param impersonatedUser The name of the impersonated user to get the routing table for, should be {@code null} for non-impersonated requests
         class RouteMessage < Struct.new(:routing_context, :bookmark, :database_name, :impersonated_user)
           SIGNATURE = 0x66
 
-          # Constructor
-
-          # @param routingContext   The routing context used to define the routing table. Multi-datacenter deployments is one of its use cases.
-          # @param bookmark         The bookmark used when getting the routing table.
-          # @param databaseName     The name of the database to get the routing table for.
-          # @param impersonatedUser The name of the impersonated user to get the routing table for, should be {@code null} for non-impersonated requests
-          def initialize(routing_context, bookmark, database_name, impersonated_user)
-            super(routing_context.freeze, bookmark, database_name, impersonated_user)
-          end
-
           def signature
             SIGNATURE
           end