neo4j-ruby-driver 6.0.3.alpha.0 → 6.2.1.beta.2

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

@@ -1,48 +0,0 @@
-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)
-        end
-
-        def to_int
-          shifted_minor = minor_version << 8
-          shifted_minor | major_version
-        end
-
-        def to_int_range(min_version)
-          if major_version != min_version.major_version
-            raise ArgumentError, 'Versions should be from the same major version'
-          elsif minor_version < min_version.minor_version
-            raise ArgumentError, 'Max version should be newer than min version'
-          end
-
-          range = minor_version - min_version.minor_version
-          shifted_range = range << 16
-          shifted_range | to_int
-        end
-
-        # @return the version in format X.Y where X is the major version and Y is the minor version
-        def to_s
-          values.join('.')
-        end
-
-        def <=>(other)
-          result = major_version <=> other.major_version
-          result == 0 ? minor_version <=> other.minor_version : result
-        end
-
-        def self.http?(protocol_version)
-          # server would respond with `HTTP..` We read 4 bytes to figure out the version. The first two are not used
-          # and therefore parse the `P` (80) for major and `T` (84) for minor.
-          protocol_version.major_version == 80 && protocol_version.minor_version == 84
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/common/common_message_reader.rb

@@ -1,51 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Common
-        class CommonMessageReader
-          def initialize(input)
-            @unpacker = input
-          end
-
-          def read(handler)
-            @unpacker.unpack_struct_header
-            type = @unpacker.unpack_struct_signature
-
-            case type
-            when Response::SuccessMessage::SIGNATURE
-              unpack_success_message(handler)
-            when Response::FailureMessage::SIGNATURE
-              unpack_failure_message(handler)
-            when Response::IgnoredMessage::SIGNATURE
-              unpack_ignored_message(handler)
-            when Response::RecordMessage::SIGNATURE
-              unpack_record_message(handler)
-            else
-              raise IOError, "Unknown message type: #{type}"
-            end
-          end
-
-          private
-
-          def unpack_success_message(output)
-            map = @unpacker.unpack
-            output.handle_success_message(map)
-          end
-
-          def unpack_failure_message(output)
-            output.handle_failure_message(**@unpacker.unpack)
-          end
-
-          def unpack_ignored_message(output)
-            output.handle_ignored_message
-          end
-
-          def unpack_record_message(output)
-            fields = @unpacker.unpack
-            output.handle_record_message(fields)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/common/common_value.rb

@@ -1,33 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Common
-        module CommonValue
-          include Packstream::PackStream::Common
-          DATE = 'D'
-          DATE_STRUCT_SIZE = 1
-          TIME = 'T'
-          TIME_STRUCT_SIZE = 2
-          LOCAL_TIME = 't'
-          LOCAL_TIME_STRUCT_SIZE = 1
-          LOCAL_DATE_TIME = 'd'
-          LOCAL_DATE_TIME_STRUCT_SIZE = 2
-          DATE_TIME_WITH_ZONE_OFFSET = 'F'
-          DATE_TIME_WITH_ZONE_OFFSET_UTC = 'I'
-          DATE_TIME_WITH_ZONE_ID = 'f'
-          DATE_TIME_WITH_ZONE_ID_UTC = 'i'
-          DATE_TIME_STRUCT_SIZE = 3
-          DURATION = 'E'
-          DURATION_TIME_STRUCT_SIZE = 4
-          POINT_2D_STRUCT_TYPE = 'X'
-          POINT_2D_STRUCT_SIZE = 3
-          POINT_3D_STRUCT_TYPE = 'Y'
-          POINT_3D_STRUCT_SIZE = 4
-
-          EPOCH = Date.parse('1970-01-01')
-          NANO_FACTOR = 1_000_000_000
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/common/common_value_packer.rb

@@ -1,104 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Common
-        module CommonValuePacker
-          include CommonValue
-          attr_writer :date_time_utc_enabled
-
-          def pack(value)
-            case value
-            when ActiveSupport::Duration
-              pack_duration(value)
-            when Types::Point
-              pack_point(value)
-            when Types::OffsetTime
-              pack_time(value)
-            when Types::LocalTime
-              pack_local_time(value)
-            when Types::LocalDateTime
-              pack_local_date_time(value)
-            when ActiveSupport::TimeWithZone
-              pack_date_time_with_zone_id(value)
-            when Time, DateTime
-              pack_date_time_with_zone_offset(value)
-            when Date
-              pack_date(value)
-            else
-              super
-            end
-          end
-
-          private
-
-          def pack_date(local_date)
-            pack_struct_header(DATE_STRUCT_SIZE, DATE)
-            pack_integer((local_date - EPOCH).to_i)
-          end
-
-          def pack_time(offset_time)
-            pack_struct_header(TIME_STRUCT_SIZE, TIME)
-            pack_nano_of_day(offset_time)
-            pack_utc_offset(offset_time)
-          end
-
-          def pack_utc_offset(time)
-            pack_integer(time.utc_offset)
-          end
-
-          def pack_nano_of_day(local_time)
-            pack_integer(((local_time.hour * 60 + local_time.min) * 60 + local_time.sec) * NANO_FACTOR + local_time.nsec)
-          end
-
-          def pack_local_time(local_time)
-            pack_struct_header(LOCAL_TIME_STRUCT_SIZE, LOCAL_TIME)
-            pack_nano_of_day(local_time)
-          end
-
-          def pack_local_date_time(local_date_time)
-            pack_struct_header(LOCAL_DATE_TIME_STRUCT_SIZE, LOCAL_DATE_TIME)
-            pack_integer(local_date_time.to_i)
-            pack_integer(local_date_time.nsec)
-          end
-
-          def pack_date_time_with_zone_id(time)
-            pack_struct_header(DATE_TIME_STRUCT_SIZE,
-                               @date_time_utc_enabled ? DATE_TIME_WITH_ZONE_ID_UTC : DATE_TIME_WITH_ZONE_ID)
-            pack_date_time(time)
-            pack_string(time.time_zone.tzinfo.identifier)
-          end
-
-          def pack_date_time(time)
-            pack_integer(time.to_i + (@date_time_utc_enabled ? 0 : time.utc_offset))
-            pack_integer(time.nsec)
-          end
-
-          def pack_date_time_with_zone_offset(time)
-            pack_struct_header(DATE_TIME_STRUCT_SIZE,
-                               @date_time_utc_enabled ? DATE_TIME_WITH_ZONE_OFFSET_UTC : DATE_TIME_WITH_ZONE_OFFSET)
-            pack_date_time(time)
-            pack_utc_offset(time)
-          end
-
-          def pack_duration(duration)
-            pack_struct_header(DURATION_TIME_STRUCT_SIZE, DURATION)
-            DurationNormalizer.normalize(duration).each(&method(:pack_integer))
-          end
-
-          def pack_point(point)
-            case point.coordinates.size
-            when 2
-              pack_struct_header(POINT_2D_STRUCT_SIZE, POINT_2D_STRUCT_TYPE)
-            when 3
-              pack_struct_header(POINT_3D_STRUCT_SIZE, POINT_3D_STRUCT_TYPE)
-            else
-              raise IOError, "Unknown type: type: #{point.class}, value: #{point.to_s}"
-            end
-            pack_integer(point.srid.to_i)
-            point.coordinates.each(&method(:pack_float))
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/messaging/common/common_value_unpacker.rb

@@ -1,256 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Common
-        module CommonValueUnpacker
-          include CommonValue
-          NODE = 'N'
-          RELATIONSHIP = 'R'
-          UNBOUND_RELATIONSHIP = 'r'
-          PATH = 'P'
-          NODE_FIELDS = 3
-          RELATIONSHIP_FIELDS = 5
-
-          def unpack_map(size)
-            size.times.to_h { [unpack.to_sym, unpack] }
-          end
-
-          def unpack_array(size)
-            size.times.map { unpack }
-          end
-
-          def unpack
-            marker_byte = read_byte
-            marker_high_nibble = marker_byte & 0xF0
-            marker_low_nibble = marker_byte & 0x0F
-
-            case marker_high_nibble
-            when TINY_STRING
-              return unpack_string(marker_low_nibble)
-            when TINY_LIST
-              return unpack_array(marker_low_nibble)
-            when TINY_MAP
-              return unpack_map(marker_low_nibble)
-            when TINY_STRUCT
-              return unpack_struct(marker_low_nibble, read_char)
-            end
-
-            case marker_byte & 0xFF # we read a signed byte but markers are unsigned
-            when NULL
-              nil
-            when TRUE
-              true
-            when FALSE
-              false
-            when FLOAT_64
-              unpack_double
-            when BYTES_8
-              unpack_bytes(read_ubyte)
-            when BYTES_16
-              unpack_bytes(read_ushort)
-            when BYTES_32
-              unpack_bytes(read_uint)
-            when STRING_8
-              unpack_string(read_ubyte)
-            when STRING_16
-              unpack_string(read_ushort)
-            when STRING_32
-              unpack_string(read_uint)
-            when LIST_8
-              unpack_array(read_ubyte)
-            when LIST_16
-              unpack_array(read_ushort)
-            when LIST_32
-              unpack_array(read_uint)
-            when MAP_8
-              unpack_map(read_ubyte)
-            when MAP_16
-              unpack_map(read_ushort)
-            when STRUCT_8
-              unpack_struct(read_ubyte, read_char)
-            when STRUCT_16
-              unpack_struct(read_ushort, read_char)
-            else
-              unpack_long(marker_byte)
-            end
-          end
-
-          def unpack_struct(size, type)
-            case type
-            when DATE
-              ensure_correct_struct_size(:DATE, DATE_STRUCT_SIZE, size)
-              unpack_date
-            when TIME
-              ensure_correct_struct_size(:TIME, TIME_STRUCT_SIZE, size)
-              unpack_time
-            when LOCAL_TIME
-              ensure_correct_struct_size(:LOCAL_TIME, LOCAL_TIME_STRUCT_SIZE, size)
-              unpack_local_time
-            when LOCAL_DATE_TIME
-              ensure_correct_struct_size(:LOCAL_DATE_TIME, LOCAL_DATE_TIME_STRUCT_SIZE, size)
-              unpack_local_date_time
-            when DATE_TIME_WITH_ZONE_OFFSET
-              ensure_correct_struct_size(:DATE_TIME_WITH_ZONE_OFFSET, DATE_TIME_STRUCT_SIZE, size)
-              unpack_date_time_with_zone_offset
-            when DATE_TIME_WITH_ZONE_OFFSET_UTC
-              ensure_correct_struct_size(:DATE_TIME_WITH_ZONE_OFFSET_UTC, DATE_TIME_STRUCT_SIZE, size)
-              unpack_date_time_with_zone_offset(true)
-            when DATE_TIME_WITH_ZONE_ID
-              ensure_correct_struct_size(:DATE_TIME_WITH_ZONE_ID, DATE_TIME_STRUCT_SIZE, size)
-              unpack_date_time_with_zone_id
-            when DATE_TIME_WITH_ZONE_ID_UTC
-              ensure_correct_struct_size(:DATE_TIME_WITH_ZONE_ID_UTC, DATE_TIME_STRUCT_SIZE, size)
-              unpack_date_time_with_zone_id(true)
-            when DURATION
-              ensure_correct_struct_size(:DURATION, DURATION_TIME_STRUCT_SIZE, size)
-              unpack_duration
-            when POINT_2D_STRUCT_TYPE
-              ensure_correct_struct_size(:POINT, POINT_2D_STRUCT_SIZE, size)
-              unpack_point2_d
-            when POINT_3D_STRUCT_TYPE
-              ensure_correct_struct_size(:POINT, POINT_3D_STRUCT_SIZE, size)
-              unpack_point3_d
-            when NODE
-              ensure_correct_struct_size(:NODE, node_fields, size)
-              adapted = unpack_node
-            when RELATIONSHIP
-              ensure_correct_struct_size(:RELATIONSHIP, relationship_fields, size)
-              unpack_relationship
-            when UNBOUND_RELATIONSHIP
-              ensure_correct_struct_size(:RELATIONSHIP, unbound_relationship_fields, size)
-              unpack_unbound_relationship
-            when PATH
-              ensure_correct_struct_size(:PATH, 3, size)
-              unpack_path
-            else
-              raise IOError, "Unknown struct type: #{type}"
-            end
-          end
-
-          private
-
-          def unpack_relationship
-            id = unpack
-            start_node_id = unpack
-            end_node_id = unpack
-            type = unpack
-            properties = unpack
-            InternalRelationship.new(id, unpack_element_id, start_node_id, unpack_element_id, end_node_id, unpack_element_id, type, **properties)
-          end
-
-          def unpack_unbound_relationship
-            id = unpack
-            type = unpack
-            properties = unpack
-            InternalRelationship.new(id, unpack_element_id, *[nil] * 4, type, **properties)
-          end
-
-          def unpack_node
-            id = unpack
-            labels = unpack.map(&:to_sym)
-            properties = unpack
-            InternalNode.new(id, unpack_element_id, *labels, **properties)
-          end
-
-          def unpack_path
-            uniq_nodes = unpack
-            uniq_rels = unpack
-            sequence = unpack
-            prev_node = uniq_nodes.first
-            nodes = [prev_node] # Start node is always 0, and isn't encoded in the sequence
-            rels = []
-            path = Types::Path.new(nodes, rels)
-            sequence.in_groups_of(2) do |rel_idx, node_idx|
-              node = uniq_nodes[node_idx]
-              nodes << node
-              rel = uniq_rels[rel_idx.abs - 1] # -1 because rel idx are 1-indexed
-              update(rel, prev_node, node, rel_idx.negative?)
-              rels << rel
-              path << Types::Path::Segment.new(prev_node, rel, node)
-              prev_node = node
-            end
-            path
-          end
-
-          def update(rel, prev_node, node, inversed)
-            # Negative rel index means this rel was traversed "inversed" from its direction
-            prev_node, node = node, prev_node if inversed
-            rel.start_node_id = prev_node.id
-            rel.end_node_id = node.id
-          end
-
-          def ensure_correct_struct_size(type_constructor, expected, actual)
-            if expected != actual
-              struct_name = type_constructor.to_s
-              raise Neo4j::Driver::Exceptions::ClientException, "Invalid message received, serialized #{struct_name} structures should have #{expected} fields, received #{struct_name} structure has #{actual} fields."
-            end
-          end
-
-          def node_fields = NODE_FIELDS
-
-          def relationship_fields = RELATIONSHIP_FIELDS
-
-          def unbound_relationship_fields = 3
-
-          def unpack_element_id = nil
-
-          def ensure_correct_struct_signature(struct_name, expected, actual)
-            if expected != actual
-              struct_name = type_constructor.to_s
-              raise Neo4j::Driver::Exceptions::ClientException, "Invalid message received, expected a `#{struct_name}`, signature 0x#{expected.to_i.to_s(16)}. Received signature was 0x#{actual.to_i.to_s(16)}."
-            end
-          end
-
-          def unpack_date
-            EPOCH + unpack
-          end
-
-          def time(nano_of_day_local, offset_seconds = nil)
-            min, sec = Rational(nano_of_day_local, NANO_FACTOR).divmod(60)
-            Time.new(0, 1, 1, *min.divmod(60), sec, offset_seconds)
-          end
-
-          def unpack_time
-            Types::OffsetTime.new(time(unpack, unpack))
-          end
-
-          def unpack_local_time
-            Types::LocalTime.new(time(unpack))
-          end
-
-          def unpack_local_date_time
-            Types::LocalDateTime.new(Time.at(unpack, unpack, :nsec).utc)
-          end
-
-          def unpack_date_time_with_zone_offset(utc = false)
-            # Time.at(unpack, unpack, :nsec, in: unpack)
-            sec = unpack
-            nsec = unpack
-            offset = unpack
-            time = Time.at(sec, nsec, :nsec).utc
-            time += offset if utc
-            Time.new(time.year, time.month, time.mday, time.hour, time.min, time.sec + Rational(nsec, 1_000_000_000),
-                     offset)
-          end
-
-          def unpack_date_time_with_zone_id(utc = false)
-            time = Time.at(unpack, unpack, :nsec).in_time_zone(TZInfo::Timezone.get(unpack))
-            utc ? time : time - time.utc_offset
-          end
-
-          def unpack_duration
-            DurationNormalizer.create(*4.times.map { unpack })
-          end
-
-          def unpack_point2_d
-            Types::Point.new(srid: unpack, x: unpack, y: unpack)
-          end
-
-          def unpack_point3_d
-            Types::Point.new(srid: unpack, x: unpack, y: unpack, z: unpack)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        class BeginMessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::BeginMessage)
-            packer.pack_struct_header(1, message.signature)
-            packer.pack(message.metadata)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        class CommitMessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::CommitMessage)
-            packer.pack_struct_header(0, Request::CommitMessage::SIGNATURE)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        class DiscardAllMessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::DiscardAllMessage)
-            packer.pack_struct_header(0, Request::DiscardAllMessage::SIGNATURE)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        class DiscardMessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::DiscardMessage)
-            packer.pack_struct_header(1, Request::DiscardMessage::SIGNATURE)
-            packer.pack(message.metadata)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        class GoodbyeMessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::GoodbyeMessage)
-            packer.pack_struct_header(0, Request::GoodbyeMessage::SIGNATURE)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        class HelloMessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::HelloMessage)
-            packer.pack_struct_header(1, message.class::SIGNATURE)
-            packer.pack(message.metadata)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        class InitMessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::InitMessage)
-            packer.pack_struct_header(2, message.signature)
-            packer.pack(message.user_agent)
-            packer.pack(message.auth_token)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        class LogoffMessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::LogoffMessage)
-            packer.pack_struct_header(0, message.class::SIGNATURE)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        class LogonMessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::LogonMessage)
-            packer.pack_struct_header(1, message.class::SIGNATURE)
-            packer.pack(message.metadata)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        class PullAllMessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::PullAllMessage)
-            packer.pack_struct_header(0, Request::PullAllMessage::SIGNATURE)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        class PullMessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::PullMessage)
-            packer.pack_struct_header(1, Request::PullMessage::SIGNATURE)
-            packer.pack(message.metadata)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        class ResetMessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::ResetMessage)
-            packer.pack_struct_header(0, Request::ResetMessage::SIGNATURE)
-          end
-        end
-      end
-    end
-  end
-end