neo4j-ruby-driver 6.2.1.beta.1 → 6.2.1.beta.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17d5f6af602136557ee743576eedcfc9a26f6a2a5ca1cc2ed2893157607c3aab
-  data.tar.gz: 744145fd8d940d40edcce5d329b654fb1ad705edfa4a142df40403840c31f93b
+  metadata.gz: 02167af06d7572708bb866aa09a7cf03492c3ea5ff78601db252a874e30c0f16
+  data.tar.gz: 5321a39b13e65469393f5485646987e178e68f2bcc9527884a087e64775096e4
 SHA512:
-  metadata.gz: 358d78b67822c5e1db7843d24a70ad5b99b26fd8be05c3390e1da030239d12fa0fc03c9ceacd102a00e7901c9f2b71055f621a78f37a5a1a0f8d62eb9ea9dd8b
-  data.tar.gz: 2727a0fa17d00511c1a31a72219855d5a104c6ec3394875101aef210484bfe42931fe0b8eb3c8de520a462c279133d5e162552db8974982a435aa84bbb642f64
+  metadata.gz: 2fb5b47bb808deadef7fcd939ab829e0e5a9b7f13ae7808a0b128a55236b874b112d9385e471f3bb098032a8185bcc039280a692d2d0e6aed213c843045cf420
+  data.tar.gz: 62c171b7b0a7f5efafa4905ffc6b200f1d3d59bd06a2f4d24fdedfaefcd61813239fcb784e5eb4b844d085147594f73f5731571d320dfea1c9dc2d1b3d69bca3

data/lib/neo4j/driver/bolt/connection.rb

@@ -15,7 +15,7 @@ module Neo4j
         # everything into the shared inbox queue for fetch_response to drain.
         # (A streaming request could register a record-routing handler instead.)
         ResponseCollector = Struct.new(:inbox) do
-          def on_record(message)  = inbox.push(message)
+          def on_record(message) = inbox.push(message)
           def on_success(message) = inbox.push(message)
           def on_failure(message) = inbox.push(message)
           def on_ignored(message) = inbox.push(message)
@@ -96,8 +96,8 @@ module Neo4j
           # stopped on close. Drives #advance and routes via the wire.
           @reader = nil
           @reader_mutex = Mutex.new
-          @reader_cv = ConditionVariable.new       # wakes the reader: a reply is expected
-          @quiescent_cv = ConditionVariable.new    # wakes drainers: in_flight hit 0
+          @reader_cv = ConditionVariable.new # wakes the reader: a reply is expected
+          @quiescent_cv = ConditionVariable.new # wakes drainers: in_flight hit 0
           @reader_stopped = false
           @broken_error = nil # set by failure fan-out; raised to inbox poppers
           @server_version = nil
@@ -129,25 +129,23 @@ module Neo4j
           # sharing one budget) wins over this connection's own.
           @read_deadline = deadline || acquisition_deadline
           resolved_addresses.each do |host, port|
-            begin
-              open_socket(host, port)
-              perform_handshake
-              perform_hello
-              @read_deadline = nil
-              @created_at = current_monotonic
-              # Connection is READY: hand steady-state reads to the dedicated
-              # reader. (Handshake/hello above read synchronously via
-              # fetch_response, so a failed connect never spawns a reader.)
-              start_reader
-              return self
-            rescue Exceptions::AuthenticationException
-              # Auth is the same regardless of which address we hit — fail fast.
-              discard_socket
-              raise
-            rescue Exceptions::ServiceUnavailableException, IOError, SystemCallError => e
-              last_error = e
-              discard_socket
-            end
+            open_socket(host, port)
+            perform_handshake
+            perform_hello
+            @read_deadline = nil
+            @created_at = current_monotonic
+            # Connection is READY: hand steady-state reads to the dedicated
+            # reader. (Handshake/hello above read synchronously via
+            # fetch_response, so a failed connect never spawns a reader.)
+            start_reader
+            return self
+          rescue Exceptions::AuthenticationException
+            # Auth is the same regardless of which address we hit — fail fast.
+            discard_socket
+            raise
+          rescue Exceptions::ServiceUnavailableException, IOError, SystemCallError => e
+            last_error = e
+            discard_socket
           end
 
           raise Exceptions::ServiceUnavailableException, 'No addresses to connect to' if last_error.nil?
@@ -246,12 +244,21 @@ module Neo4j
           begin
             @wire&.enqueue(Message.goodbye, @collector)
             bytes = @wire&.take_outbound
-            @write_mutex.synchronize { @socket.write(bytes); @socket.flush } if bytes && !bytes.empty?
+            if bytes && !bytes.empty?
+              @write_mutex.synchronize do
+                @socket.write(bytes)
+                @socket.flush
+              end
+            end
           rescue StandardError
             # closing anyway
           end
           stop_reader
-          @socket&.close rescue nil
+          begin
+            @socket&.close
+          rescue StandardError
+            nil
+          end
         end
 
         def closed?
@@ -521,7 +528,7 @@ module Neo4j
             response = fetch_response
             case response
             when Message::Success then break # PULL summary — end of stream
-            when Message::Record  then row ||= fields.zip(response.fields).to_h
+            when Message::Record then row ||= fields.zip(response.fields).to_h
             else response.assert_success! # FAILURE / IGNORED — raises
             end
           end
@@ -663,7 +670,11 @@ module Neo4j
 
         def discard_socket
           stop_reader
-          @socket&.close rescue nil
+          begin
+            @socket&.close
+          rescue StandardError
+            nil
+          end
           @socket = nil
           # Reset all per-attempt I/O state so a retry on the next address (or a
           # later reset!/drain loop) doesn't carry a phantom in-flight request or
@@ -709,7 +720,8 @@ module Neo4j
           end
         rescue IOError, SystemCallError => e
           fail_broken(Exceptions::ServiceUnavailableException.new(
-                        "Connection to #{@address || @uri} broken: #{e.class}: #{e.message}"))
+                        "Connection to #{@address || @uri} broken: #{e.class}: #{e.message}"
+                      ))
         end
 
         # The dedicated reader: the sole socket reader for this connection's
@@ -779,10 +791,18 @@ module Neo4j
           # Wake the parked reader (@reader_cv) and any drainer blocked in
           # #wait_quiescent (@quiescent_cv) — stopping is a terminal transition
           # they must observe, else a concurrent reset!/fetch_all/alive? hangs.
-          @reader_mutex.synchronize { @reader_stopped = true; @reader_cv.broadcast; @quiescent_cv.broadcast }
+          @reader_mutex.synchronize do
+            @reader_stopped = true
+            @reader_cv.broadcast
+            @quiescent_cv.broadcast
+          end
           return unless reader
 
-          @socket&.close rescue nil
+          begin
+            @socket&.close
+          rescue StandardError
+            nil
+          end
           reader.join unless reader == Thread.current
         end
 
@@ -814,7 +834,11 @@ module Neo4j
         end
 
         def mark_closed_broken
-          @socket&.close rescue nil
+          begin
+            @socket&.close
+          rescue StandardError
+            nil
+          end
           @closed = true
           fire_on_close
         end
@@ -926,10 +950,16 @@ module Neo4j
           # test_should_fail_when_acquisition_timeout_is_reached_first, where
           # acquisition 2s < connection 720s).
           connect_timeout = [timeout&.to_f, remaining_read_budget].compact.min
-          tcp_socket = connect_timeout ? Socket.tcp(bare_host, port, connect_timeout: connect_timeout) : TCPSocket.new(bare_host, port)
+          tcp_socket = if connect_timeout
+                         Socket.tcp(bare_host, port,
+                                    connect_timeout: connect_timeout)
+                       else
+                         TCPSocket.new(bare_host, port)
+                       end
         rescue SystemCallError, SocketError => e
           raise Exceptions::ServiceUnavailableException,
-                "Unable to connect to #{format_address(host, port)}, ensure the database is running and that there is a working network connection to it. (#{e.message})"
+                "Unable to connect to #{format_address(host,
+                                                       port)}, ensure the database is running and that there is a working network connection to it. (#{e.message})"
         else
           @address = format_address(host, port)
           tcp_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
@@ -961,11 +991,19 @@ module Neo4j
           ssl.post_connection_check(hostname) if tls.verify_hostname?
           ssl
         rescue OpenSSL::SSL::SSLError => e
-          tcp_socket.close rescue nil
+          begin
+            tcp_socket.close
+          rescue StandardError
+            nil
+          end
           raise Exceptions::SecurityException,
                 "TLS handshake to #{format_address(hostname, port)} failed: #{e.message}"
         rescue SystemCallError, IOError => e
-          tcp_socket.close rescue nil
+          begin
+            tcp_socket.close
+          rescue StandardError
+            nil
+          end
           raise Exceptions::ServiceUnavailableException,
                 "Connection lost during TLS handshake to #{format_address(hostname, port)}: #{e.message}"
         end
@@ -1047,7 +1085,6 @@ module Neo4j
           seconds = hints && hints[:'connection.recv_timeout_seconds']
           @recv_timeout = seconds if seconds&.positive?
         end
-
       end
     end
   end

data/lib/neo4j/driver/bolt/handshake.rb

@@ -38,9 +38,9 @@ module Neo4j
         # DISCARD_ALL, single-DB, no routing in HELLO).
         SLOTS = [
           MANIFEST_SENTINEL,
-          0x00_08_08_05,  # 5.0–5.8
-          0x00_02_04_04,  # 4.2–4.4
-          0x00_00_00_03   # 3.0
+          0x00_08_08_05, # 5.0–5.8
+          0x00_02_04_04, # 4.2–4.4
+          0x00_00_00_03 # 3.0
         ].freeze
 
         # Versions we'd accept from a manifest, highest-preference first.
@@ -91,15 +91,19 @@ module Neo4j
           @socket.flush
 
           server_reply = read_int32!('Server closed the connection during handshake')
-          raise Exceptions::ServiceUnavailableException,
-                'Server does not support any of the proposed Bolt versions' if server_reply.zero?
+          if server_reply.zero?
+            raise Exceptions::ServiceUnavailableException,
+                  'Server does not support any of the proposed Bolt versions'
+          end
 
           # An HTTP server on the Bolt port replies with an HTTP status
           # line; its first four bytes spell "HTTP". Mirror Java's helpful
           # error instead of reporting a bogus protocol version.
-          raise Exceptions::ClientException,
-                'Server responded HTTP. Make sure you are not trying to connect to the http ' \
-                'endpoint (HTTP defaults to port 7474 whereas BOLT defaults to port 7687)' if server_reply == HTTP_REPLY
+          if server_reply == HTTP_REPLY
+            raise Exceptions::ClientException,
+                  'Server responded HTTP. Make sure you are not trying to connect to the http ' \
+                  'endpoint (HTTP defaults to port 7474 whereas BOLT defaults to port 7687)'
+          end
 
           server_reply == MANIFEST_SENTINEL ? negotiate_manifest : server_reply
         end
@@ -170,8 +174,8 @@ module Neo4j
           buf = String.new(encoding: Encoding::BINARY)
           while buf.bytesize < n
             case (chunk = @socket.read_nonblock(n - buf.bytesize, exception: false))
-            when :wait_readable then (@socket.wait_readable(remaining_budget) || return)
-            when :wait_writable then (@socket.wait_writable(remaining_budget) || return)
+            when :wait_readable then @socket.wait_readable(remaining_budget) || return
+            when :wait_writable then @socket.wait_writable(remaining_budget) || return
             when nil then return
             else buf << chunk
             end

data/lib/neo4j/driver/bolt/message/failure.rb

@@ -18,14 +18,14 @@ module Neo4j
           # Code-prefix → driver exception class. Order matters: more specific
           # patterns must come first.
           EXCEPTION_FOR_CODE = [
-            [%r{^Neo\.ClientError\.Security\.Unauthorized},         Exceptions::AuthenticationException],
-            [%r{^Neo\.ClientError\.Security\.AuthorizationExpired}, Exceptions::AuthorizationExpiredException],
-            [%r{^Neo\.ClientError\.Security\.TokenExpired},         Exceptions::TokenExpiredException],
-            [%r{^Neo\.ClientError\.Security},                       Exceptions::SecurityException],
-            [%r{^Neo\.ClientError\.Database\.DatabaseNotFound},     Exceptions::FatalDiscoveryException],
-            [%r{^Neo\.ClientError},                                 Exceptions::ClientException],
-            [%r{^Neo\.TransientError},                              Exceptions::TransientException],
-            [%r{^Neo\.DatabaseError},                               Exceptions::DatabaseException]
+            [/^Neo\.ClientError\.Security\.Unauthorized/, Exceptions::AuthenticationException],
+            [/^Neo\.ClientError\.Security\.AuthorizationExpired/, Exceptions::AuthorizationExpiredException],
+            [/^Neo\.ClientError\.Security\.TokenExpired/, Exceptions::TokenExpiredException],
+            [/^Neo\.ClientError\.Security/, Exceptions::SecurityException],
+            [/^Neo\.ClientError\.Database\.DatabaseNotFound/, Exceptions::FatalDiscoveryException],
+            [/^Neo\.ClientError/, Exceptions::ClientException],
+            [/^Neo\.TransientError/, Exceptions::TransientException],
+            [/^Neo\.DatabaseError/, Exceptions::DatabaseException]
           ].freeze
 
           # Two `TransientError` codes the server may send that are actually

data/lib/neo4j/driver/bolt/message/record.rb

@@ -17,7 +17,7 @@ module Neo4j
           end
 
           def assert_success!
-            raise Exceptions::ClientException, "Unexpected RECORD where SUCCESS was expected"
+            raise Exceptions::ClientException, 'Unexpected RECORD where SUCCESS was expected'
           end
 
           # A RECORD is a streamed row, not a request summary — it never

data/lib/neo4j/driver/bolt/message.rb

@@ -27,7 +27,7 @@ module Neo4j
         FAILURE = 0x7F
 
         class << self
-          # Note: HELLO message building is now handled by protocol-specific handlers
+          # NOTE: HELLO message building is now handled by protocol-specific handlers
           # This method kept for backward compatibility but shouldn't be used directly
           def hello(user_agent:, auth:, routing: nil)
             extra = { user_agent: user_agent }

data/lib/neo4j/driver/bolt/pool.rb

@@ -141,8 +141,8 @@ module Neo4j
           bump(created: -1, leased: -1)
         end
 
-        def shutdown(&block)
-          @stack.shutdown(&block)
+        def shutdown(&)
+          @stack.shutdown(&)
           # Every connection is closed now — keep the metrics truthful so a
           # post-close snapshot reports nothing live.
           @metrics_lock.synchronize { @created = @leased = 0 }

data/lib/neo4j/driver/bolt/protocol/v44.rb

@@ -1,4 +1,4 @@
- # frozen_string_literal: true
+# frozen_string_literal: true
 
 module Neo4j
   module Driver

data/lib/neo4j/driver/bolt/record_buffer.rb

@@ -39,12 +39,12 @@ module Neo4j
           @low_watermark = low_watermark || [@high_watermark / 2, 1].max
           @mutex = Mutex.new
           @cv = ConditionVariable.new
-          @records = []           # incrementally filled by the reader, drained by the cursor
-          @has_more = true        # server may have more records for this stream
-          @pull_in_flight = true  # the first PULL is pipelined with RUN — promise unfulfilled
-          @ended = false          # terminal SUCCESS/IGNORED seen → no more records
-          @error = nil            # stream failed; re-raised to the cursor after buffered records
-          @summary = nil          # terminating SUCCESS metadata
+          @records = [] # incrementally filled by the reader, drained by the cursor
+          @has_more = true # server may have more records for this stream
+          @pull_in_flight = true # the first PULL is pipelined with RUN — promise unfulfilled
+          @ended = false # terminal SUCCESS/IGNORED seen → no more records
+          @error = nil # stream failed; re-raised to the cursor after buffered records
+          @summary = nil # terminating SUCCESS metadata
         end
 
         # --- Producer (reader) side -----------------------------------------
@@ -52,7 +52,10 @@ module Neo4j
         # Append a decoded record and wake a cursor parked in #await. Never blocks
         # (unbounded); the cursor's watermark bounds how much the server ships.
         def push_record(record)
-          @mutex.synchronize { @records.push(record); @cv.broadcast }
+          @mutex.synchronize do
+            @records.push(record)
+            @cv.broadcast
+          end
         end
 
         # The current batch's terminal SUCCESS arrived — resolve the promise.
@@ -60,7 +63,11 @@ module Neo4j
         # so the cursor may issue the next once it drains past the low watermark.
         # Wake a cursor parked in #await waiting for exactly this.
         def batch_complete(has_more:)
-          @mutex.synchronize { @has_more = has_more; @pull_in_flight = false; @cv.broadcast }
+          @mutex.synchronize do
+            @has_more = has_more
+            @pull_in_flight = false
+            @cv.broadcast
+          end
         end
 
         # Final batch (terminating SUCCESS without has_more, or IGNORED): stash the

data/lib/neo4j/driver/bolt/wire.rb

@@ -34,9 +34,9 @@ module Neo4j
           @protocol = protocol
           @packer = PackStream::Packer.new(@protocol)
           @protocol.configure_packer(@packer)
-          @outbound = binary_string  # consumer-only (enqueue/take_outbound)
-          @inbound = binary_string   # reader-only: received bytes not yet parsed
-          @message = binary_string   # reader-only: chunks of the in-progress message
+          @outbound = binary_string # consumer-only (enqueue/take_outbound)
+          @inbound = binary_string # reader-only: received bytes not yet parsed
+          @message = binary_string # reader-only: chunks of the in-progress message
           # Response-ordering FIFO. Bolt replies in request order, so each sent
           # request pushes the handler that will receive its response(s); the
           # front handler always owns the next reply. A handler is any response
@@ -187,7 +187,7 @@ module Neo4j
         def register_hydration_handlers(unpacker)
           unpacker.register_hydration_handler(Message::SUCCESS) { |fields| Message::Success.new(fields[0] || {}) }
           unpacker.register_hydration_handler(Message::FAILURE) { |fields| Message::Failure.new(fields[0] || {}) }
-          unpacker.register_hydration_handler(Message::RECORD)  { |fields| Message::Record.new(fields[0] || []) }
+          unpacker.register_hydration_handler(Message::RECORD) { |fields| Message::Record.new(fields[0] || []) }
           unpacker.register_hydration_handler(Message::IGNORED) { |_| Message::Ignored.new }
 
           # Signature 0x4E - Node

data/lib/neo4j/driver/direct/connection_provider.rb

@@ -183,7 +183,11 @@ module Neo4j
 
         def close
           @closed = true
-          @pool&.shutdown { |conn| conn.close rescue nil }
+          @pool&.shutdown do |conn|
+            conn.close
+          rescue StandardError
+            nil
+          end
         end
 
         private

data/lib/neo4j/driver/driver.rb

@@ -46,13 +46,13 @@ module Neo4j
 
         begin
           result = yield session
-        rescue => block_error
+        rescue StandardError => e
           # Block raised; preserve as primary, attach close-time failures
           # as suppressed (Java try-with-resources semantics).
           begin
             session.close
           rescue Exceptions::Neo4jException => close_error
-            block_error.add_suppressed(close_error) if block_error.respond_to?(:add_suppressed)
+            e.add_suppressed(close_error) if e.respond_to?(:add_suppressed)
           end
           raise
         else

data/lib/neo4j/driver/exceptions/no_such_record_exception.rb

@@ -6,7 +6,7 @@ module Neo4j
       class NoSuchRecordException < RuntimeError
         EMPTY = 'Cannot retrieve a single record, because this result is empty.'
         TOO_MANY = 'Expected a result with a single record, but this result ' \
-          'contains at least one more. Ensure your query returns only one record.'
+                   'contains at least one more. Ensure your query returns only one record.'
         NO_MORE = 'No more records'
         NO_PEEK_PAST = 'Cannot peek past the last record'
 

data/lib/neo4j/driver/internal/duration_normalizer.rb

@@ -14,8 +14,10 @@ module Neo4j
           # Check the sign before rounding: a tiny negative timeout
           # (e.g. -0.4ms) would otherwise round to 0 and slip through.
           ms = timeout.to_f * 1000
-          raise Exceptions::ClientException,
-                "Transaction timeout must not be negative, but was #{ms}ms" if ms.negative?
+          if ms.negative?
+            raise Exceptions::ClientException,
+                  "Transaction timeout must not be negative, but was #{ms}ms"
+          end
 
           ms.round
         end

data/lib/neo4j/driver/internal/validator.rb

@@ -16,6 +16,7 @@ module Neo4j
 
         def self.require_non_nil!(obj, message = nil)
           raise ArgumentError, [message, "can't be nil"].compact.join(' ') if obj.nil?
+
           obj
         end
 
@@ -24,14 +25,17 @@ module Neo4j
         # object carries its own text, so only bare strings are checked.
         def self.require_query_text!(query)
           raise ArgumentError, 'Cypher query text should not be null' if query.nil?
-          raise ArgumentError, 'Cypher query text should not be an empty string' if query.is_a?(String) && query.strip.empty?
+          if query.is_a?(String) && query.strip.empty?
+            raise ArgumentError,
+                  'Cypher query text should not be an empty string'
+          end
 
           query
         end
 
         def self.require_non_nil_credentials!(username, password)
-          require_non_nil! username, "Username"
-          require_non_nil! password, "Password"
+          require_non_nil! username, 'Username'
+          require_non_nil! password, 'Password'
         end
       end
     end

data/lib/neo4j/driver/packstream/markers.rb

@@ -7,37 +7,37 @@ module Neo4j
       # See https://neo4j.com/docs/bolt/current/packstream/ for the full table.
       module Markers
         TINY_STRING = 0x80
-        TINY_LIST   = 0x90
-        TINY_MAP    = 0xA0
+        TINY_LIST = 0x90
+        TINY_MAP = 0xA0
         TINY_STRUCT = 0xB0
 
-        NULL     = 0xC0
+        NULL = 0xC0
         FLOAT_64 = 0xC1
-        FALSE    = 0xC2
-        TRUE     = 0xC3
+        BOOLEAN_FALSE = 0xC2
+        BOOLEAN_TRUE = 0xC3
 
-        INT_8  = 0xC8
+        INT_8 = 0xC8
         INT_16 = 0xC9
         INT_32 = 0xCA
         INT_64 = 0xCB
 
-        BYTES_8  = 0xCC
+        BYTES_8 = 0xCC
         BYTES_16 = 0xCD
         BYTES_32 = 0xCE
 
-        STRING_8  = 0xD0
+        STRING_8 = 0xD0
         STRING_16 = 0xD1
         STRING_32 = 0xD2
 
-        LIST_8  = 0xD4
+        LIST_8 = 0xD4
         LIST_16 = 0xD5
         LIST_32 = 0xD6
 
-        MAP_8  = 0xD8
+        MAP_8 = 0xD8
         MAP_16 = 0xD9
         MAP_32 = 0xDA
 
-        STRUCT_8  = 0xDC
+        STRUCT_8 = 0xDC
         STRUCT_16 = 0xDD
 
         # PackStream V2 (Bolt 6.1+): a UUID is a top-level value — the marker

data/lib/neo4j/driver/packstream/packer.rb

@@ -110,7 +110,7 @@ module Neo4j
         end
 
         def pack_boolean(value)
-          @buffer << [value ? TRUE : FALSE].pack('C')
+          @buffer << [value ? BOOLEAN_TRUE : BOOLEAN_FALSE].pack('C')
         end
 
         def pack_integer(value)
@@ -246,10 +246,12 @@ module Neo4j
           # matching hydration handlers in Bolt::Connection.
           if @use_utc_datetime
             epoch_seconds = value.to_i
-            offset_sig, zone_sig = 0x49, 0x69
+            offset_sig = 0x49
+            zone_sig = 0x69
           else
             epoch_seconds = value.to_i + tz_offset
-            offset_sig, zone_sig = 0x46, 0x66
+            offset_sig = 0x46
+            zone_sig = 0x66
           end
           zone_name = named_zone_for(value)
 

data/lib/neo4j/driver/packstream/unpacker.rb

@@ -29,7 +29,8 @@ module Neo4j
         def unpack_uuid_value
           hex = read_bytes(16).unpack1('H*')
           Types::UUID.from_string(
-            "#{hex[0, 8]}-#{hex[8, 4]}-#{hex[12, 4]}-#{hex[16, 4]}-#{hex[20, 12]}")
+            "#{hex[0, 8]}-#{hex[8, 4]}-#{hex[12, 4]}-#{hex[16, 4]}-#{hex[20, 12]}"
+          )
         end
 
         # A ProtocolException (not a bare RuntimeError) so the failure reaches
@@ -49,9 +50,9 @@ module Neo4j
           case marker
           when NULL
             nil
-          when FALSE
+          when BOOLEAN_FALSE
             false
-          when TRUE
+          when BOOLEAN_TRUE
             true
           when FLOAT_64
             read_bytes(8).unpack1('G')
@@ -159,7 +160,8 @@ module Neo4j
 
         def read_bytes(n)
           data = @io.read(n)
-          raise IOError, "Unexpected end of stream" if data.nil? || data.bytesize < n
+          raise IOError, 'Unexpected end of stream' if data.nil? || data.bytesize < n
+
           data
         end
       end

data/lib/neo4j/driver/record.rb

@@ -14,13 +14,7 @@ module Neo4j
         end
       end
 
-      def keys
-        @keys
-      end
-
-      def values
-        @values
-      end
+      attr_reader :keys, :values
 
       def [](key)
         case key
@@ -41,8 +35,8 @@ module Neo4j
         @map.dup
       end
 
-      def each(&block)
-        @map.each(&block)
+      def each(&)
+        @map.each(&)
       end
     end
   end