neo4j-ruby-driver 5.7.0.alpha.4 → 6.0.3.alpha.0-java

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

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

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

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

@@ -1,24 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        # Encodes the ROUTE message to the stream
-        class RouteMessageEncoder
-          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&.values || [])
-            packer.pack(option(message))
-          end
-
-          private
-
-          def option(message)
-            message.database_name
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        # Encodes the ROUTE message to the stream
-        class RouteV44MessageEncoder < RouteMessageEncoder
-          private
-
-          def option(message)
-            if message.impersonated_user && !message.database_name
-              { imp_user: message.impersonated_user }
-            elsif message.database_name
-              { db: message.database_name }
-            else
-              {}
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        class RunMessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::RunMessage)
-            packer.pack_struct_header(2, message.signature)
-            packer.pack(message.query)
-            packer.pack(message.parameters)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Messaging
-      module Encode
-        class RunWithMetadataMessageEncoder
-          def encode(message, packer)
-            Util::Preconditions.check_argument(message, Request::RunWithMetadataMessage)
-            packer.pack_struct_header(3, message.signature)
-            packer.pack(message.query)
-            packer.pack(message.parameters)
-            packer.pack(message.metadata)
-          end
-        end
-      end
-    end
-  end
-end