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

data/ruby/neo4j/driver/internal/handlers/pulln/auto_pull_response_handler.rb

@@ -3,6 +3,7 @@ module Neo4j::Driver
     module Handlers
       module Pulln
         class AutoPullResponseHandler < BasicPullResponseHandler
+          include Enumerable
           delegate :signal, to: :@records
           LONG_MAX_VALUE = 2 ** 63 - 1
 
@@ -55,7 +56,7 @@ module Neo4j::Driver
 
           private def handle_failure(error)
             # error has not been propagated to the user, remember it
-            unless fail_record_future(error) && fail_summary_future(error)
+            unless fail_record_future(error) || fail_summary_future(error)
               @failure = error
             end
           end
@@ -64,26 +65,31 @@ module Neo4j::Driver
             while @records.empty? && !done?
               @records.wait
             end
-            @records.items.first
+            @records.items.first&.then(&Util::ResultHolder.method(:successful)) or
+              completed_with_value_if_no_failure(nil)
           end
 
           def next_async
-            dequeue_record if peek_async
+            peek_async.then { |record| dequeue_record if record }
           end
 
           def consume_async
             @records.items.clear
-            return completed_with_value_if_no_failure(@summary) if done?
-            cancel
-            @summary
+            cancel unless done?
+            completed_with_value_if_no_failure(@summary)
           end
 
-          def list_async(&map_function)
-            pull_all_async.then_apply(-> (summary) { records_as_list(&map_function) })
+          def each
+            pull_all_async.then do
+              unless done?
+                raise Exceptions::IllegalStateException, "Can't get records as list because SUCCESS or FAILURE did not arrive"
+              end
+              @records.each { |record| yield record }
+            end
           end
 
           def pull_all_failure_async
-            pull_all_async
+            pull_all_async.chain { |_, error| error }
           end
 
           def pre_populate_records
@@ -94,12 +100,9 @@ module Neo4j::Driver
 
           def pull_all_async
             return completed_with_value_if_no_failure(@summary) if done?
-
-            request(FetchSizeUtil::UNLIMITED_FETCH_SIZE)
-
-            @summary_future = java.util.concurrent.CompletableFuture.new if @summary_future.nil?
-
-            @summary_future
+            (@summary_future ||= Util::ResultHolder.new).tap do |_|
+              request(FetchSizeUtil::UNLIMITED_FETCH_SIZE)
+            end
           end
 
           def enqueue_record(record)
@@ -122,14 +125,6 @@ module Neo4j::Driver
             record
           end
 
-          def records_as_list(&map_function)
-            unless done?
-              raise Exceptions::IllegalStateException, "Can't get records as list because SUCCESS or FAILURE did not arrive"
-            end
-
-            @records.each.map(&map_function)
-          end
-
           def extract_failure
             @failure or raise Exceptions::IllegalStateException, "Can't extract failure because it does not exist"
           ensure
@@ -137,39 +132,34 @@ module Neo4j::Driver
           end
 
           def complete_record_future(record)
-            unless @record_future.nil?
-              future = @record_future
-              @record_future = nil
-              future.complete(record)
-            end
+            @record_future&.succeed(record)
+            @record_future = nil
           end
 
           def complete_summary_future(summary)
-            unless @summary_future.nil?
-              future = @summary_future
-              @summary_future = nil
-              future.complete(summary)
-            end
+            @summary_future&.succeed(summary)
+            @summary_future = nil
           end
 
           def fail_record_future(error)
-            unless @record_future.nil?
-              future = @record_future
-              @record_future = nil
-              future.complete(record)
-              return true
-            end
+            @record_future&.fail(error)
+          ensure
+            @record_future = nil
+          end
 
-            false
+          def fail_summary_future(error)
+            @summary_future&.fail(error)
+          ensure
+            @summary_future = nil
           end
 
           def completed_with_value_if_no_failure(value)
-            @failure ? extract_failure : value
+            if @failure
+              Util::ResultHolder.failed(extract_failure)
+            else
+              Util::ResultHolder.successful(value)
+            end
           end
-
-          # def request(size)
-          #   @auto_pull_enabled ? Async { super } : super
-          # end
         end
       end
     end

data/ruby/neo4j/driver/internal/handlers/pulln/basic_pull_response_handler.rb

@@ -99,7 +99,7 @@ module Neo4j::Driver
           end
 
           def done?
-            @state == State::SUCEEDED_STATE || @state == State::FAILURE_STATE
+            @state == State::SUCCEEDED_STATE || @state == State::FAILURE_STATE
           end
 
           private def extract_result_summary(**metadata)
@@ -147,7 +147,7 @@ module Neo4j::Driver
           end
 
           module State
-            READY_STATE = Class.new do
+            class Ready
               def on_success(context, metadata)
                 context.state = SUCCEEDED_STATE
                 context.complete_with_success(metadata)
@@ -171,15 +171,17 @@ module Neo4j::Driver
                 context.state = CANCELLED_STATE
                 context.discard_all
               end
-            end.new
+            end
+
+            READY_STATE = Ready.new
 
-            STREAMING_STATE = Class.new do
+            class Streaming
               def on_success(context, metadata)
                 if metadata[:has_more]
                   context.state = READY_STATE
                   context.success_has_more
                 else
-                  context.state = SUCEEDED_STATE
+                  context.state = SUCCEEDED_STATE
                   context.complete_with_success(metadata)
                 end
               end
@@ -202,15 +204,17 @@ module Neo4j::Driver
               def cancel(context)
                 context.state = CANCELLED_STATE
               end
-            end.new
+            end
+
+            STREAMING_STATE = Streaming.new
 
-            CANCELLED_STATE = Class.new do
+            class Cancelled
               def on_success(context, metadata)
                 if metadata[:has_more]
                   context.state = CANCELLED_STATE
                   context.discard_all
                 else
-                  context.state = SUCEEDED_STATE
+                  context.state = SUCCEEDED_STATE
                   context.complete_with_success(metadata)
                 end
               end
@@ -231,11 +235,13 @@ module Neo4j::Driver
               def cancel(context)
                 context.state = CANCELLED_STATE
               end
-            end.new
+            end
+
+            CANCELLED_STATE = Cancelled.new
 
-            SUCEEDED_STATE = Class.new do
+            class Succeeded
               def on_success(context, metadata)
-                context.state = SUCEEDED_STATE
+                context.state = SUCCEEDED_STATE
                 context.complete_with_success(metadata)
               end
 
@@ -245,21 +251,23 @@ module Neo4j::Driver
               end
 
               def on_record(context, _fields)
-                context.state = SUCEEDED_STATE
+                context.state = SUCCEEDED_STATE
               end
 
               def request(context, _n)
-                context.state = SUCEEDED_STATE
+                context.state = SUCCEEDED_STATE
               end
 
               def cancel(context)
-                context.state = SUCEEDED_STATE
+                context.state = SUCCEEDED_STATE
               end
-            end.new
+            end
+
+            SUCCEEDED_STATE = Succeeded.new
 
-            FAILURE_STATE = Class.new do
+            class Failed
               def on_success(context, metadata)
-                context.state = SUCEEDED_STATE
+                context.state = SUCCEEDED_STATE
                 context.complete_with_success(metadata)
               end
 
@@ -279,7 +287,9 @@ module Neo4j::Driver
               def cancel(context)
                 context.state = FAILURE_STATE
               end
-            end.new
+            end
+
+            FAILURE_STATE = Failed.new
           end
         end
       end

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

@@ -3,11 +3,17 @@ module Neo4j::Driver
     module Handlers
       class RollbackTxResponseHandler
         include Spi::ResponseHandler
+
+        def initialize(result_holder)
+          @result_holder = result_holder
+        end
+
         def on_success(_metadata)
+          @result_holder.succeed
         end
 
         def on_failure(error)
-          raise error
+          @result_holder.fail(error)
         end
 
         def on_record(fields)

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

@@ -21,10 +21,6 @@ module Neo4j::Driver
         InternalSession.new(new_session(**session_config))
       end
 
-      def rx_session(**session_config)
-        InternalRxSession.new(new_session(**session_config))
-      end
-
       def async_session(**session_config)
         InternalAsyncSession.new(new_session(**session_config))
       end

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

@@ -4,34 +4,27 @@ module Neo4j::Driver
       extend Synchronizable
       include Enumerable
       sync :keys, :has_next?, :next, :single, :peek, :consume
+      delegate :keys, to: :@cursor
 
       def initialize(connection, cursor)
         @connection = connection
         @cursor = cursor
       end
 
-      def keys
-        @keys ||=
-          begin
-            @cursor.peek_async
-            @cursor.keys
-          end
-      end
-
       def has_next?
-        @cursor.peek_async
+        @cursor.peek_async.result!
       end
 
       def next
-        @cursor.next_async || raise(Exceptions::NoSuchRecordException.no_more)
+        @cursor.next_async.result! || raise(Exceptions::NoSuchRecordException.no_more)
       end
 
       def single
-        @cursor.single_async
+        @cursor.single_async.result!
       end
 
       def peek
-        @cursor.peek_async or raise Exceptions::NoSuchRecordException.no_peek_past
+        @cursor.peek_async.result! or raise Exceptions::NoSuchRecordException.no_peek_past
       end
 
       def each
@@ -39,7 +32,7 @@ module Neo4j::Driver
       end
 
       def consume
-        @cursor.consume_async
+        @cursor.consume_async.result!
       end
 
       def remove
@@ -48,10 +41,6 @@ module Neo4j::Driver
 
       private
 
-      def blocking_get(stage)
-        Util::Futures.blocking_get(stage, &method(:terminate_connection_on_thread_interrupt))
-      end
-
       def terminate_connection_on_thread_interrupt
         @connection.terminate_and_release('Thread interrupted while waiting for result to arrive')
       end

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

@@ -17,7 +17,7 @@ module Neo4j::Driver
         Validator.require_hash_parameters!(parameters)
         cursor = @session.run_async(Query.new(query, **parameters), **TransactionConfig.new(**config.compact)) do
           terminate_connection_on_thread_interrupt('Thread interrupted while running query in session')
-        end
+        end.result!
 
         # query executed, it is safe to obtain a connection in a blocking way
         connection = @session.connection_async

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

@@ -10,28 +10,28 @@ module Neo4j::Driver
       end
 
       def commit
-        @tx.commit_async
+        @tx.commit_async.result!
         # org.neo4j.driver.internal.util.Futures.blockingGet(@tx.commit_async) do
         #   terminate_connection_on_thread_interrupt('Thread interrupted while committing the transaction')
         # end
       end
 
       def rollback
-        @tx.rollback_async
+        @tx.rollback_async.result!
         # org.neo4j.driver.internal.util.Futures.blockingGet(@tx.rollback_async) do
         #   terminate_connection_on_thread_interrupt('Thread interrupted while rolling back the transaction')
         # end
       end
 
       def close
-        @tx.close_async
+        @tx.close_async.result!
         # org.neo4j.driver.internal.util.Futures.blockingGet(@tx.close_async) do
         #     terminate_connection_on_thread_interrupt('Thread interrupted while closing the transaction')
         #   end
       end
 
       def run(query, **parameters)
-        cursor = @tx.run_async(Query.new(query, **parameters))
+        cursor = @tx.run_async(Query.new(query, **parameters)).result!
         # cursor = org.neo4j.driver.internal.util.Futures.blockingGet(@tx.run_async(to_statement(query, parameters))) do
         #   terminate_connection_on_thread_interrupt('Thread interrupted while running query in transaction')
         # end

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

@@ -4,7 +4,7 @@ module Neo4j::Driver
       class AbstractMessageWriter
         def initialize(packer)
           @packer = Internal::Validator.require_non_nil!(packer)
-          @encoders_by_message_signature = Internal::Validator.require_non_nil!(build_encoders)
+          @encoders_by_message_signature = Internal::Validator.require_non_nil!(build_encoders).transform_values(&:new)
         end
 
         def write(msg)

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

@@ -4,7 +4,10 @@ module Neo4j::Driver
       module Request
         class AbstractStreamingMessage < Struct.new(:n, :qid)
           STREAM_LIMIT_UNLIMITED = -1
-          alias metadata to_h
+
+          def metadata
+            to_h.compact
+          end
 
           def to_s
             "#{name} #{metadata}"

data/ruby/neo4j/driver/internal/messaging/v3/bolt_protocol_v3.rb

@@ -36,12 +36,16 @@ module Neo4j::Driver
             connection.write_and_flush(begin_message, Handlers::BeginTxResponseHandler.new)
           end
 
-          def commit_transaction(connection, bookmark_holder)
-            connection.write_and_flush(Request::CommitMessage::COMMIT, Handlers::CommitTxResponseHandler.new(bookmark_holder))
+          def commit_transaction(connection)
+            Util::ResultHolder.new.tap do |result_holder|
+              connection.write_and_flush(Request::CommitMessage::COMMIT, Handlers::CommitTxResponseHandler.new(result_holder))
+            end
           end
 
           def rollback_transaction(connection)
-            connection.write_and_flush(Request::RollbackMessage::ROLLBACK, Handlers::RollbackTxResponseHandler.new)
+            Util::ResultHolder.new.tap do |result_holder|
+              connection.write_and_flush(Request::RollbackMessage::ROLLBACK, Handlers::RollbackTxResponseHandler.new(result_holder))
+            end
           end
 
           def run_in_auto_commit_transaction(connection, query, bookmark_holder, config, fetch_size)

data/ruby/neo4j/driver/internal/messaging/v3/message_writer_v3.rb

@@ -3,22 +3,22 @@ module Neo4j::Driver
     module Messaging
       module V3
         class MessageWriterV3 < AbstractMessageWriter
+          COMMON_ENCODERS = {
+            Request::HelloMessage::SIGNATURE => Encode::HelloMessageEncoder,
+            Request::GoodbyeMessage::SIGNATURE => Encode::GoodbyeMessageEncoder,
+            Request::RunWithMetadataMessage::SIGNATURE => Encode::RunWithMetadataMessageEncoder,
+            Request::BeginMessage::SIGNATURE => Encode::BeginMessageEncoder,
+            Request::CommitMessage::SIGNATURE => Encode::CommitMessageEncoder,
+            Request::RollbackMessage::SIGNATURE => Encode::RollbackMessageEncoder,
+            Request::ResetMessage::SIGNATURE => Encode::ResetMessageEncoder,
+          }
           private
 
           def build_encoders
-            {
-              Request::HelloMessage::SIGNATURE => Encode::HelloMessageEncoder.new,
-              Request::GoodbyeMessage::SIGNATURE => Encode::GoodbyeMessageEncoder.new,
-
-              Request::RunWithMetadataMessage::SIGNATURE => Encode::RunWithMetadataMessageEncoder.new,
-              Request::DiscardAllMessage::SIGNATURE => Encode::DiscardAllMessageEncoder.new,
-              Request::PullAllMessage::SIGNATURE => Encode::PullAllMessageEncoder.new,
-
-              Request::BeginMessage::SIGNATURE => Encode::BeginMessageEncoder.new,
-              Request::CommitMessage::SIGNATURE => Encode::CommitMessageEncoder.new,
-              Request::RollbackMessage::SIGNATURE => Encode::RollbackMessageEncoder.new,
-              Request::ResetMessage::SIGNATURE => Encode::ResetMessageEncoder.new,
-            }
+            COMMON_ENCODERS.merge(
+              Request::DiscardAllMessage::SIGNATURE => Encode::DiscardAllMessageEncoder,
+              Request::PullAllMessage::SIGNATURE => Encode::PullAllMessageEncoder,
+            )
           end
         end
       end

data/ruby/neo4j/driver/internal/messaging/v4/message_writer_v4.rb

@@ -2,24 +2,13 @@ module Neo4j::Driver
   module Internal
     module Messaging
       module V4
-        class MessageWriterV4 < AbstractMessageWriter
+        class MessageWriterV4 < V3::MessageWriterV3
           private
 
           def build_encoders
-            {
-              Request::HelloMessage::SIGNATURE => Encode::HelloMessageEncoder.new,
-              Request::GoodbyeMessage::SIGNATURE => Encode::GoodbyeMessageEncoder.new,
-              Request::RunWithMetadataMessage::SIGNATURE => Encode::RunWithMetadataMessageEncoder.new,
-
-              Request::DiscardAllMessage::SIGNATURE => Encode::DiscardAllMessageEncoder.new, # new
-              Request::PullMessage::SIGNATURE => Encode::PullMessageEncoder.new, # new
-
-              Request::BeginMessage::SIGNATURE => Encode::BeginMessageEncoder.new,
-              Request::CommitMessage::SIGNATURE => Encode::CommitMessageEncoder.new,
-              Request::RollbackMessage::SIGNATURE => Encode::RollbackMessageEncoder.new,
-
-              Request::ResetMessage::SIGNATURE => Encode::ResetMessageEncoder.new,
-            }
+            COMMON_ENCODERS.merge(
+              Request::DiscardMessage::SIGNATURE => Encode::DiscardMessageEncoder,
+              Request::PullMessage::SIGNATURE => Encode::PullMessageEncoder)
           end
         end
       end

data/ruby/neo4j/driver/internal/messaging/v43/message_writer_v43.rb

@@ -7,25 +7,11 @@ module Neo4j::Driver
         # This version is able to encode all the versions existing on v4.2, but it encodes
 
         # new messages such as ROUTE
-        class MessageWriterV43 < AbstractMessageWriter
+        class MessageWriterV43 < V4::MessageWriterV4
           private
 
           def build_encoders
-            {
-              Request::HelloMessage::SIGNATURE => Encode::HelloMessageEncoder.new,
-              Request::GoodbyeMessage::SIGNATURE => Encode::GoodbyeMessageEncoder.new,
-              Request::RunWithMetadataMessage::SIGNATURE => Encode::RunWithMetadataMessageEncoder.new,
-              Request::RouteMessage::SIGNATURE => Encode::RouteMessageEncoder.new, # new
-
-              Request::DiscardMessage::SIGNATURE => Encode::DiscardMessageEncoder.new,
-              Request::PullMessage::SIGNATURE => Encode::PullMessageEncoder.new,
-
-              Request::BeginMessage::SIGNATURE => Encode::BeginMessageEncoder.new,
-              Request::CommitMessage::SIGNATURE => Encode::CommitMessageEncoder.new,
-              Request::RollbackMessage::SIGNATURE => Encode::RollbackMessageEncoder.new,
-
-              Request::ResetMessage::SIGNATURE => Encode::ResetMessageEncoder.new,
-            }
+            super.merge(Request::RouteMessage::SIGNATURE => Encode::RouteMessageEncoder)
           end
         end
       end

data/ruby/neo4j/driver/internal/messaging/v44/message_writer_v44.rb

@@ -2,22 +2,11 @@ module Neo4j::Driver
   module Internal
     module Messaging
       module V44
-        class MessageWriterV44 < AbstractMessageWriter
+        class MessageWriterV44 < V4::MessageWriterV4
           private
 
           def build_encoders
-            {
-              Request::HelloMessage::SIGNATURE => Encode::HelloMessageEncoder.new,
-              Request::GoodbyeMessage::SIGNATURE => Encode::GoodbyeMessageEncoder.new,
-              Request::RunWithMetadataMessage::SIGNATURE => Encode::RunWithMetadataMessageEncoder.new,
-              Request::RouteMessage::SIGNATURE => Encode::RouteV44MessageEncoder.new,
-              Request::DiscardMessage::SIGNATURE => Encode::DiscardMessageEncoder.new,
-              Request::PullMessage::SIGNATURE => Encode::PullMessageEncoder.new,
-              Request::BeginMessage::SIGNATURE => Encode::BeginMessageEncoder.new,
-              Request::CommitMessage::SIGNATURE => Encode::CommitMessageEncoder.new,
-              Request::RollbackMessage::SIGNATURE => Encode::RollbackMessageEncoder.new,
-              Request::ResetMessage::SIGNATURE => Encode::ResetMessageEncoder.new,
-            }
+            super.merge(Request::RouteMessage::SIGNATURE => Encode::RouteV44MessageEncoder)
           end
         end
       end

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

@@ -22,7 +22,7 @@ module Neo4j::Driver
         @string_value
       end
 
-      private def attributes
+      def attributes
         super + [@resolved_addresses]
       end
 

data/ruby/neo4j/driver/internal/retry/exponential_backoff_retry_logic.rb

@@ -143,7 +143,7 @@ module Neo4j::Driver
         end
 
         def add_suppressed(error, suppressed_errors)
-          suppressed_errors&.reject(&error.method(:equal?))&.each(&error.method(:add_suppressed))
+          suppressed_errors&.reject(&error.method(:equal?))&.each(&error.method(:add_suppressed)) if error.is_a? Exceptions::Neo4jException
         end
       end
     end

data/ruby/neo4j/driver/internal/util/metadata_extractor.rb

@@ -2,8 +2,6 @@ module Neo4j::Driver
   module Internal
     module Util
       class MetadataExtractor
-        ABSENT_QUERY_ID = -1
-
         def initialize(result_available_after_metadata_key, result_consumed_after_metadata_key)
           @result_available_after_metadata_key = result_available_after_metadata_key
           @result_consumed_after_metadata_key = result_consumed_after_metadata_key
@@ -14,7 +12,7 @@ module Neo4j::Driver
         end
 
         def extract_query_id(metadata)
-          metadata[:qid] || ABSENT_QUERY_ID
+          metadata[:qid]
         end
 
         def extract_result_available_after(metadata)

data/ruby/neo4j/driver/internal/util/result_holder.rb

@@ -0,0 +1,72 @@
+module Neo4j::Driver
+  module Internal
+    module Util
+      class ResultHolder
+        attr :error
+
+        def self.successful(result = nil)
+          new.tap { |holder| holder.succeed(result) }
+        end
+
+        def self.failed(error)
+          new.tap { |holder| holder.fail(error) }
+        end
+
+        def succeed(result = nil)
+          if @completed
+            false
+          else
+            @result = result
+            true
+          end
+        ensure
+          @completed = true
+        end
+
+        def fail(error)
+          if @completed
+            false
+          else
+            @error = error
+            true
+          end
+        ensure
+          @completed = true
+        end
+
+        def result!
+          raise @error if @error
+          @result
+        end
+
+        def then
+          @error ? self : ResultHolder.successful(yield(@result))
+        end
+
+        # &block returns a ResultHolder
+        def compose
+          @error ? self : yield(@result)
+        end
+
+        def chain
+          ResultHolder.successful(yield(@result, @error))
+        rescue => error
+          ResultHolder.failed(error)
+        end
+
+        def side
+          yield(@result, @error)
+          self
+        end
+
+        def copy_to(result_holder)
+          if @error
+            result_holder.fail(@error)
+          else
+            result_holder.succeed(@result)
+          end
+        end
+      end
+    end
+  end
+end