neo4j-ruby-driver 1.7.6 → 4.4.0.alpha.3

data/ffi/neo4j/driver/internal/session_factory_impl.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      class SessionFactoryImpl
-        attr_reader :connection_provider
-        delegate :close, :verify_connectivity, to: :connection_provider
-
-        def initialize(connection_provider, retry_logic, config)
-          @connection_provider = connection_provider
-          @retry_logic = retry_logic
-          @config = config
-        end
-
-        def new_instance(mode, bookmarks)
-          create_session(connection_provider, @retry_logic, mode).tap { |session| session.bookmarks = bookmarks }
-        end
-
-        private
-
-        def create_session(connection_provider, retry_logic, mode, logging = nil)
-          NetworkSession.new(connection_provider, mode, retry_logic, logging)
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/summary/internal_result_summary.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Summary
-        class InternalResultSummary
-          attr_reader :server, :counters, :statement, :result_available_after, :result_consumed_after
-          delegate :notifications, :profile, to: :@metadata
-
-          def initialize(statement, result_available_after, bolt_connection)
-            @statement = statement
-            @result_available_after = result_available_after
-            @server = InternalServerInfo.new(bolt_connection)
-            @metadata = RecursiveOpenStruct.new(
-              underscore_keys(Value::ValueAdapter.to_ruby(Bolt::Connection.metadata(bolt_connection))),
-              recurse_over_arrays: true
-            )
-            @result_consumed_after = @metadata.result_consumed_after || @metadata.t_last
-            @counters = InternalSummaryCounters.new(@metadata.stats)
-          end
-
-          def notifications
-            @metadata.notifications || []
-          end
-
-          def plan
-            @metadata.plan || profile
-          end
-
-          alias has_plan? plan
-          alias has_profile? profile
-
-          def method_missing(method)
-            @metadata.send(method)
-          end
-
-          private
-
-          def underscore_keys(arg)
-            case arg
-            when Array
-              arg.map(&method(:underscore_keys))
-            when Hash
-              arg.map { |key, value| [translate_key(key), underscore_keys(value)] }.to_h
-            else
-              arg
-            end
-          end
-
-          def translate_key(key)
-            case key
-            when :type
-              :statement_type
-            when :args
-              :arguments
-            when :rows
-              :records
-            else
-              key.to_s.underscore.to_sym
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/summary/internal_server_info.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Summary
-        class InternalServerInfo
-          attr_reader :address, :version
-
-          def initialize(bolt_connection)
-            address = Bolt::Connection.remote_endpoint(bolt_connection)
-            @address = %i[host port].map { |method| Bolt::Address.send(method, address).first }.join(':')
-            @version = Bolt::Connection.server(bolt_connection).first
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/summary/internal_summary_counters.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Summary
-        class InternalSummaryCounters
-          def initialize(stats)
-            @stats = stats || RecursiveOpenStruct.new
-          end
-
-          def contains_updates?
-            @stats.to_h.values.any?(&:positive?)
-          end
-
-          def method_missing(method)
-            @stats.send(method) || 0
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Util
-        class MetadataExtractor
-          def initialize(result_available_after_metadata_key, result_consumed_after_metadata_key); end
-
-          def extract_bookmarks(metadata); end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/base_time_value.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module BaseTimeValue
-          NANO_FACTOR = 1_000_000_000
-
-          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 to_neo_values(local_time)
-            ((local_time.hour * 60 + local_time.min) * 60 + local_time.sec) * NANO_FACTOR + local_time.nsec
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/date_value.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module DateValue
-          CODE = :D
-          extend StructureValue
-          EPOCH = Date.parse('1970-01-01')
-
-          class << self
-            def to_ruby_value(epoch_day)
-              EPOCH + epoch_day
-            end
-
-            def to_neo_values(date)
-              (date - EPOCH).to_i
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/duration_value.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module DurationValue
-          CODE = :E
-          extend StructureValue
-
-          class << self
-            def to_ruby_value(months, days, seconds, nanoseconds)
-              ActiveSupport::Duration.months(months) +
-                ActiveSupport::Duration.days(days) +
-                ActiveSupport::Duration.seconds(seconds) +
-                ActiveSupport::Duration.seconds(nanoseconds * BigDecimal('1e-9'))
-            end
-
-            def to_neo_values(object)
-              DurationNormalizer.normalize(object)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/local_date_time_value.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module LocalDateTimeValue
-          CODE = :d
-          extend StructureValue
-
-          class << self
-            def to_ruby_value(epoch_second_utc, nsec)
-              Types::LocalDateTime.new(Time.at(epoch_second_utc, nsec, :nsec).utc)
-            end
-
-            def to_neo_values(local_date_time)
-              [local_date_time.to_i, local_date_time.nsec]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/local_time_value.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module LocalTimeValue
-          CODE = :t
-          extend StructureValue
-          extend BaseTimeValue
-
-          def self.to_ruby_value(nano_of_day_local)
-            Types::LocalTime.new(time(nano_of_day_local))
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/node_value.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module NodeValue
-          CODE = :N
-          extend StructureValue
-
-          def self.to_ruby_value(id, labels, properties)
-            Types::Node.new(id, labels.map(&:to_sym), properties)
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/offset_time_value.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module OffsetTimeValue
-          CODE = :T
-          extend StructureValue
-          extend BaseTimeValue
-
-          class << self
-            def to_ruby_value(nano_of_day_local, offset_seconds)
-              Types::OffsetTime.new(time(nano_of_day_local, offset_seconds))
-            end
-
-            def to_neo_values(offset_time)
-              [super, offset_time.utc_offset]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/path_value.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module PathValue
-          CODE = :P
-          extend StructureValue
-          class << self
-            def to_ruby_value(uniq_nodes, uniq_rels, sequence)
-              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
-
-            private
-
-            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
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/point2_d_value.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module Point2DValue
-          CODE = :X
-          extend StructureValue
-
-          class << self
-            def to_ruby_value(srid, x, y)
-              Types::Point.new(srid: srid, x: x, y: y)
-            end
-
-            def to_neo_values(point)
-              [point.srid.to_i, *point.coordinates]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/point3_d_value.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module Point3DValue
-          CODE = :Y
-          extend StructureValue
-
-          class << self
-            def to_ruby_value(srid, x, y, z)
-              Types::Point.new(srid: srid, x: x, y: y, z: z)
-            end
-
-            def to_neo_values(point)
-              [point.srid.to_i, *point.coordinates]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/relationship_value.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module RelationshipValue
-          CODE = :R
-          extend StructureValue
-
-          def self.to_ruby_value(id, start_node_id, end_node_id, type, properties)
-            Types::Relationship.new(id, start_node_id, end_node_id, type, properties)
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/structure_value.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module StructureValue
-          def self.extended(mod)
-            code = mod.const_get('CODE').to_s.getbyte(0)
-            (@modules ||= {})[code] = mod
-            mod.define_singleton_method(:code) { code }
-          end
-
-          def self.to_ruby(value)
-            @modules[Bolt::Structure.code(value)]&.to_ruby_specific(value)
-          end
-
-          def to_ruby_specific(value)
-            to_ruby_value(*Array.new(size, &method(:ruby_value).curry.call(value)))
-          end
-
-          def to_neo(value, object)
-            Bolt::Value.format_as_structure(value, code, size)
-            Array(to_neo_values(object)).each_with_index do |elem, index|
-              ValueAdapter.to_neo(Bolt::Structure.value(value, index), elem)
-            end
-          end
-
-          private
-
-          def ruby_value(value, index)
-            ValueAdapter.to_ruby(Bolt::Structure.value(value, index))
-          end
-
-          def size
-            @size ||= method(:to_ruby_value).arity
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/time_with_zone_id_value.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module TimeWithZoneIdValue
-          CODE = :f
-          extend StructureValue
-
-          class << self
-            def to_ruby_value(epoch_second_local, nsec, zone_id_string)
-              time = Time.at(epoch_second_local, nsec, :nsec).in_time_zone(TZInfo::Timezone.get(zone_id_string))
-              time - time.utc_offset
-            end
-
-            def to_neo_values(time)
-              [time.to_i + time.utc_offset, time.nsec, time.time_zone.tzinfo.identifier]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/time_with_zone_offset_value.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module TimeWithZoneOffsetValue
-          CODE = :F
-          extend StructureValue
-
-          class << self
-            def to_ruby_value(epoch_second_local, nsec, offset)
-              time = Time.at(epoch_second_local, nsec, :nsec).utc
-              Time.new(time.year, time.month, time.mday, time.hour, time.min, time.sec + Rational(nsec, 1_000_000_000),
-                       offset)
-              # In ruby 2.6.x
-              # Time.at(sec, nsec, :nsec, tz: offset)
-            end
-
-            def to_neo_values(time)
-              [time.to_i + time.utc_offset, time.nsec, time.utc_offset]
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/unbound_relationship_value.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module UnboundRelationshipValue
-          CODE = :r
-          extend StructureValue
-
-          def self.to_ruby_value(id, type, properties)
-            Types::Relationship.new(id, nil, nil, type, properties)
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/internal/value/value_adapter.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Internal
-      module Value
-        module ValueAdapter
-          class << self
-            def to_ruby(value)
-              case Bolt::Value.type(value)
-              when :bolt_null
-                nil
-              when :bolt_boolean
-                Bolt::Boolean.get(value) == 1
-              when :bolt_integer
-                Bolt::Integer.get(value)
-              when :bolt_float
-                Bolt::Float.get(value)
-              when :bolt_bytes
-                Types::Bytes.new(Array.new(Bolt::Value.size(value)) { |i| Bolt::Bytes.get(value, i) }.pack('C*'))
-              when :bolt_string
-                Bolt::String.get(value).read_string(Bolt::Value.size(value)).force_encoding(Encoding::UTF_8)
-              when :bolt_dictionary
-                Array.new(Bolt::Value.size(value)) do |i|
-                  [to_ruby(Bolt::Dictionary.key(value, i)).to_sym, to_ruby(Bolt::Dictionary.value(value, i))]
-                end.to_h
-              when :bolt_list
-                Array.new(Bolt::Value.size(value)) { |i| to_ruby(Bolt::List.value(value, i)) }
-              when :bolt_structure
-                StructureValue.to_ruby(value)
-              else
-                raise Exception, 'unsupported neo4j type'
-              end
-            end
-
-            def to_neo(value, object)
-              case object
-              when nil
-                Bolt::Value.format_as_null(value)
-              when TrueClass
-                Bolt::Value.format_as_boolean(value, 1)
-              when FalseClass
-                Bolt::Value.format_as_boolean(value, 0)
-              when Integer
-                Bolt::Value.format_as_integer(value, object)
-              when Float
-                Bolt::Value.format_as_float(value, object)
-              when Types::Bytes
-                Bolt::Value.format_as_bytes(value, object, object.size)
-              when String
-                object = object.encode(Encoding::UTF_8) unless object.encoding == Encoding::UTF_8
-                Bolt::Value.format_as_string(value, object, object.bytesize)
-              when Symbol
-                to_neo(value, object.to_s)
-              when Hash
-                Bolt::Value.format_as_dictionary(value, object.size)
-                object.each_with_index do |(key, elem), index|
-                  key = key.to_s
-                  Bolt::Dictionary.set_key(value, index, key, key.bytesize)
-                  to_neo(Bolt::Dictionary.value(value, index), elem)
-                end
-              when Types::Path
-                Exceptions::ClientException.unable_to_convert(object)
-              when Enumerable
-                object = object.to_a
-                Bolt::Value.format_as_list(value, object.size)
-                object.each_with_index { |elem, index| to_neo(Bolt::List.value(value, index), elem) }
-              when ActiveSupport::Duration
-                DurationValue.to_neo(value, object)
-              when Neo4j::Driver::Types::Point
-                case object.coordinates.size
-                when 2
-                  Point2DValue
-                when 3
-                  Point3DValue
-                else
-                  raise Exception
-                end&.to_neo(value, object)
-              when Types::OffsetTime
-                OffsetTimeValue.to_neo(value, object)
-              when Types::LocalTime
-                LocalTimeValue.to_neo(value, object)
-              when Types::LocalDateTime
-                LocalDateTimeValue.to_neo(value, object)
-              when ActiveSupport::TimeWithZone
-                TimeWithZoneIdValue.to_neo(value, object)
-              when Time, DateTime
-                TimeWithZoneOffsetValue.to_neo(value, object)
-              when Date
-                DateValue.to_neo(value, object)
-              else
-                Exceptions::ClientException.unable_to_convert(object)
-              end
-              value
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/net/server_address.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Net
-      module ServerAddress
-        def self.of(host, port)
-          Internal::BoltServerAddress.new(host, port)
-        end
-      end
-    end
-  end
-end

data/ffi/neo4j/driver/statement.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    class Statement
-      attr_reader :text, :parameters
-
-      def initialize(text, parameters = nil)
-        Internal::Validator.require_hash_parameters!(parameters)
-        @text = text
-        @parameters = parameters || {}
-      end
-    end
-  end
-end