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

data/lib/neo4j/driver/types/offset_time.rb

@@ -3,16 +3,87 @@
 module Neo4j
   module Driver
     module Types
-      class OffsetTime < Time
-        class << self
-          FIELDS = %i[hour min sec nsec utc_offset].freeze
+      # Bolt OffsetTime — time of day with a fixed UTC offset, stored as
+      # nanoseconds-since-midnight (in local wall clock) plus offset
+      # seconds. Equivalent to java.time.OffsetTime. Was previously
+      # called Types::Time, which collided cosmetically with ::Time.
+      class OffsetTime < TemporalValue
+        attr_reader :nanoseconds, :tz_offset_seconds
 
-          def significant_fields
-            FIELDS
-          end
+        def self.significant_fields = %i[nanoseconds tz_offset_seconds]
+
+        def initialize(nanoseconds, tz_offset_seconds)
+          @nanoseconds = nanoseconds % NANOS_PER_DAY
+          @tz_offset_seconds = tz_offset_seconds
+        end
+
+        def self.from_nanos(nanoseconds, tz_offset_seconds) = new(nanoseconds, tz_offset_seconds)
+
+        # Build from a Ruby Time — its wall clock plus its UTC offset.
+        # Reuses LocalTime's field extraction. Mirrors LocalDateTime.from_time.
+        def self.from_time(time)
+          new(LocalTime.from_time(time).nanoseconds, time.utc_offset)
+        end
+
+        # Accepts "12:34:56.123456789+01:00", "12:34:56Z", or any string
+        # containing such a time-with-offset component.
+        def self.parse(string)
+          match = string.match(/(\d{1,2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?([Z+-][\d:]*)?/)
+          raise ArgumentError, "Invalid OffsetTime format: #{string}" unless match
+
+          nanos = LocalTime.send(:parse_nanos,
+                                 match[1].to_i, match[2].to_i, (match[3] || 0).to_i, match[4] || '0')
+          new(nanos, parse_offset(match[5] || 'Z'))
+        end
+
+        def self.parse_offset(str)
+          return 0 if str == 'Z'
+          raise ArgumentError, "Invalid timezone offset: #{str}" unless str =~ /^([+-])(\d{2}):?(\d{2})?$/
+
+          sign = ::Regexp.last_match(1) == '+' ? 1 : -1
+          sign * (::Regexp.last_match(2).to_i * 3600 + (::Regexp.last_match(3) || 0).to_i * 60)
         end
+        private_class_method :parse_offset
 
-        delegate(*significant_fields, to: :@time)
+        def hour = (@nanoseconds / NANOS_PER_HOUR) % 24
+        def minute = (@nanoseconds / NANOS_PER_MINUTE) % 60
+        def second = (@nanoseconds / NANOS_PER_SECOND) % 60
+        def nanosecond = @nanoseconds % NANOS_PER_SECOND
+
+        # Add a numeric or ActiveSupport::Duration. Sub-second precision
+        # preserved (see LocalTime#+).
+        def +(other)
+          self.class.new(@nanoseconds + (other.to_f * NANOS_PER_SECOND).round, @tz_offset_seconds)
+        end
+
+        def to_s
+          # Apply the sign to the formatted offset as a whole, not to
+          # `hours` alone — Ruby integer division for `-12600 / 3600` is
+          # -4 (floor toward -∞), which would render -03:30 as -04:30.
+          abs = @tz_offset_seconds.abs
+          sign = @tz_offset_seconds.negative? ? '-' : '+'
+          format('%02d:%02d:%02d.%09d%s%02d:%02d',
+                 hour, minute, second, nanosecond,
+                 sign, abs / 3600, (abs % 3600) / 60)
+        end
+
+        # Order by underlying UTC instant. Two OffsetTimes representing
+        # the same UTC instant in different offsets compare equal under
+        # <=>; == still requires same fields (they're not the same value).
+        def <=>(other)
+          return nil unless other.is_a?(OffsetTime)
+
+          utc_nanos <=> other.utc_nanos
+        end
+
+        protected
+
+        # UTC = local − offset. Positive offset means "ahead of UTC", so
+        # the UTC instant is *earlier* (smaller nanos). The previous
+        # implementation added instead of subtracting, inverting ordering.
+        def utc_nanos
+          @nanoseconds - (@tz_offset_seconds * NANOS_PER_SECOND)
+        end
       end
     end
   end

data/lib/neo4j/driver/types/path.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      # Represents a Path in the Neo4j graph
+      # A path is a sequence of alternating nodes and relationships
+      class Path
+        include Enumerable
+
+        attr_reader :nodes, :relationships
+
+        def initialize(nodes, relationships, segments)
+          @nodes = nodes
+          @relationships = relationships
+          @segments = segments
+        end
+
+        # Returns the start node of the path
+        def start
+          @nodes.first
+        end
+        alias start_node start
+
+        # Returns the end node of the path
+        def end
+          @nodes.last
+        end
+        alias end_node end
+
+        # Returns the number of relationships in the path (number of segments)
+        def length
+          @relationships.length
+        end
+
+        # Check if the path contains the given node
+        def contains_node?(node)
+          @nodes.any? { |n| n.id == node.id }
+        end
+
+        # Check if the path contains the given relationship
+        def contains_relationship?(relationship)
+          @relationships.any? { |r| r.id == relationship.id }
+        end
+
+        # Iterate over segments in the path
+        # Each segment represents a relationship and its start/end nodes
+        def each(&)
+          @segments.each(&)
+        end
+
+        # Represents a segment of a path (a relationship and its start/end nodes)
+        class Segment
+          attr_reader :start_node, :end_node, :relationship
+
+          def initialize(start_node, end_node, relationship)
+            @start_node = start_node
+            @end_node = end_node
+            @relationship = relationship
+          end
+
+          alias start start_node
+          alias end end_node
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/types/point.rb

@@ -3,36 +3,56 @@
 module Neo4j
   module Driver
     module Types
+      # Point (2D or 3D)
       class Point
-        attr_accessor :srid, :x, :y, :z
+        attr_reader :srid, :x, :y, :z
 
-        SRID = {
-          'WGS-84': 4326,
-          'WGS-84-3D': 4979,
-          cartesian: 7203,
-          'cartesian-3D': 9157
-        }.with_indifferent_access.freeze
+        # SRID constants for coordinate reference systems
+        WGS_84_2D = 4326 # Geographic 2D (longitude, latitude)
+        WGS_84_3D = 4979 # Geographic 3D (longitude, latitude, height)
+        CARTESIAN_2D = 7203 # Cartesian 2D (x, y)
+        CARTESIAN_3D = 9157 # Cartesian 3D (x, y, z)
 
-        def initialize(args)
-          self.x = args[:longitude] || args[:x]
-          self.y = args[:latitude] || args[:y]
-          self.z = args[:height] || args[:z]
-          self.srid = args[:srid] || SRID[args[:crs] || implied_crs(args[:longitude] || args[:latitude])]
+        def initialize(srid: nil, x: nil, y: nil, z: nil, longitude: nil, latitude: nil, height: nil)
+          # Handle longitude/latitude aliases for x/y
+          if longitude || latitude
+            @x = (longitude || x).to_f
+            @y = (latitude || y).to_f
+            @z = (height || z)&.to_f
+            # Use WGS-84 SRID for geographic coordinates
+            @srid = srid || (@z ? WGS_84_3D : WGS_84_2D)
+          else
+            @x = x.to_f
+            @y = y.to_f
+            @z = z&.to_f
+            # Use Cartesian SRID for x/y/z coordinates
+            @srid = srid || (@z ? CARTESIAN_3D : CARTESIAN_2D)
+          end
+        end
+
+        def dimension
+          @z.nil? ? 2 : 3
         end
 
         def coordinates
           [x, y, z].compact.map(&:to_f)
         end
 
-        private
-
-        def implied_crs(geo)
-          if geo
-            z ? :'WGS-84-3D' : :'WGS-84'
+        def to_s
+          if @z
+            "Point{srid=#{@srid}, x=#{@x}, y=#{@y}, z=#{@z}}"
           else
-            z ? :'cartesian-3D' : :cartesian
+            "Point{srid=#{@srid}, x=#{@x}, y=#{@y}}"
           end
         end
+
+        def ==(other)
+          other.is_a?(Point) &&
+            other.srid == @srid &&
+            (other.x - @x).abs < 0.00001 &&
+            (other.y - @y).abs < 0.00001 &&
+            (@z.nil? || (other.z - @z).abs < 0.00001)
+        end
       end
     end
   end

data/lib/neo4j/driver/types/relationship.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      # Represents a Relationship in the Neo4j graph.
+      # Mirrors Java's org.neo4j.driver.types.Relationship — an Entity with a
+      # type and start/end node ids.
+      class Relationship < Entity
+        attr_reader :start_node_id, :end_node_id, :type,
+                    :start_node_element_id, :end_node_element_id
+
+        # Bolt 4.x wire doesn't include start/end_node_element_id —
+        # PackStream hydration passes nil for those slots. Fall back to
+        # the stringified node id so callers always see a value
+        # (matches what Java's driver does for 4.x). Path-bound
+        # relationships pass the actual node element_ids from #bind,
+        # which override the fallback.
+        def initialize(id, start_node_id, end_node_id, type, properties,
+                       element_id = nil, start_node_element_id = nil,
+                       end_node_element_id = nil)
+          super(id, properties, element_id)
+          @start_node_id = start_node_id
+          @end_node_id = end_node_id
+          @type = type
+          @start_node_element_id = start_node_element_id || start_node_id.to_s
+          @end_node_element_id = end_node_element_id || end_node_id.to_s
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/types/temporal_value.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      # Shared base for the Bolt temporal value types: Duration,
+      # LocalDateTime, LocalTime, OffsetTime. Each subclass declares its
+      # `significant_fields` and gets `<=>`, `==`, `eql?`, `hash` derived
+      # from them automatically. Comparable mixed in here gives `<`, `>`,
+      # `between?`, `clamp` etc. for free.
+      class TemporalValue
+        include Comparable
+
+        NANOS_PER_SECOND = 1_000_000_000
+        NANOS_PER_MINUTE = 60 * NANOS_PER_SECOND
+        NANOS_PER_HOUR = 60 * NANOS_PER_MINUTE
+        NANOS_PER_DAY = 24 * NANOS_PER_HOUR
+
+        def self.significant_fields
+          raise NotImplementedError, "#{self} must define .significant_fields"
+        end
+
+        def significant
+          self.class.significant_fields.map { send(it) }
+        end
+
+        def <=>(other)
+          return nil unless other.is_a?(self.class)
+
+          significant <=> other.significant
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && significant == other.significant
+        end
+        alias eql? ==
+
+        def hash
+          significant.hash
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/types/unbound_relationship.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      # Represents an unbound relationship (used in paths before binding to
+      # nodes). An Entity with a type but no start/end nodes yet.
+      class UnboundRelationship < Entity
+        attr_reader :type
+
+        def initialize(id, type, properties, element_id = nil)
+          super(id, properties, element_id)
+          @type = type
+        end
+
+        # Bind this relationship to specific start and end nodes
+        def bind(start_node_id, end_node_id, start_node_element_id = nil, end_node_element_id = nil)
+          Relationship.new(@id, start_node_id, end_node_id, @type, @properties,
+                           @element_id, start_node_element_id, end_node_element_id)
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/types/unresolvable_zoned_date_time.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      # A ZonedDateTime the driver received with a zone id its runtime's time
+      # zone database can't resolve (e.g. the server sent "Europe/Neo4j").
+      #
+      # Hydration can't build a real Time, but raising mid-record on the reader
+      # thread would break the connection and strand the whole result — so the
+      # failure is deferred into this placeholder. Any consumer that tries to
+      # interpret the value raises (naming the zone), matching the Java driver,
+      # while the record and connection stay intact so an open transaction can
+      # still roll back cleanly.
+      class UnresolvableZonedDateTime
+        attr_reader :zone_name
+
+        def initialize(zone_name)
+          @zone_name = zone_name
+        end
+
+        # The driver error this value stands in for. Raised by any consumer
+        # that tries to use it (the testkit backend on serialize; a public-API
+        # caller via #value).
+        def error
+          Exceptions::ClientException.new(
+            "The server returned a ZonedDateTime with a zone id (#{@zone_name.inspect}) " \
+            "that this runtime's time zone database does not recognise"
+          )
+        end
+
+        def value
+          raise error
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/types/unsupported_type.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      # A value whose Bolt struct type is newer than this driver understands
+      # (Bolt 6.0+ can push forward-compat markers, struct signature 0x3F). The
+      # driver can't materialise the real value, but it must not crash — it
+      # surfaces the type's name, the protocol version that introduced it, and
+      # an optional server message so callers can react. Mirrors the Java
+      # driver's UnsupportedType.
+      class UnsupportedType
+        attr_reader :name, :min_protocol_version, :message
+
+        # `major`/`minor` are the wire ints (e.g. 6, 10); expose them joined as
+        # "major.minor" the way testkit / the Java driver report it.
+        def initialize(name, major, minor, message = nil)
+          @name = name
+          @min_protocol_version = "#{major}.#{minor}"
+          @message = message
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/types/uuid.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      # A Neo4j UUID value (Bolt 6.1+). An opaque, immutable value type
+      # mirroring java.util.UUID (which JRuby uses natively) and Python's
+      # uuid.UUID — construct via `from_string`, read the canonical
+      # hyphenated form via `to_s`. `new` is private so flavor-agnostic
+      # code goes through `from_string`, the one constructor that also
+      # exists on java.util.UUID.
+      class UUID
+        def self.from_string(value) = new(value)
+        private_class_method :new
+
+        def initialize(value)
+          @value = value.to_s
+        end
+
+        def to_s = @value
+
+        def ==(other) = other.is_a?(UUID) && other.to_s == @value
+        alias eql? ==
+
+        def hash = @value.hash
+      end
+    end
+  end
+end

data/{ruby → lib}/neo4j/driver/version.rb

@@ -2,6 +2,6 @@
 
 module Neo4j
   module Driver
-    VERSION = '6.0.3.alpha.0'
+    VERSION = '6.2.1.beta.2'
   end
 end

data/lib/neo4j/driver.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'connection_pool'
+require 'neo4j-ruby-driver_loader'
+require 'openssl'
+require 'socket'
+require 'stringio'
+require 'tzinfo'
+
+module Neo4j
+  module Driver
+    Loader.load(:mri)
+    AuthTokenManager = Internal::InternalAuthTokenManager
+  end
+end

data/lib/neo4j-ruby-driver_loader.rb

@@ -1,32 +1,46 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/isolated_execution_state' if Gem::Requirement.create('>= 7').satisfied_by?(Gem.loaded_specs["activesupport"].version) # TODO: this should not be necessary https://github.com/rails/rails/issues/43851
-require 'active_support/deprecator' if Gem::Requirement.create('>= 7.1').satisfied_by?(Gem.loaded_specs["activesupport"].version)
-require 'active_support/deprecation'
-require 'active_support/core_ext/numeric/time'
-require 'active_support/duration'
-require 'active_support/time'
 require 'date'
+require 'forwardable'
+require 'time'
 require 'uri'
 require 'zeitwerk'
 
 module Neo4j
   module Driver
     class Loader
-      def self.load
-        loader = Zeitwerk::Loader.new
-        loader.tag = 'neo4j-ruby-driver'
-        loader.push_dir(File.expand_path(__dir__))
-        driver_specific_dir = File.dirname(File.dirname(caller_locations(1..1).first.path))
-        loader.push_dir(driver_specific_dir)
-        yield loader if block_given?
-        loader.ignore(File.expand_path('neo4j*ruby*driver*.rb', __dir__))
-        loader.ignore(File.expand_path('org', __dir__))
-        loader.inflector = Zeitwerk::GemInflector.new(File.expand_path('neo4j/driver', driver_specific_dir))
-        loader.setup
-        loader.eager_load
+      class << self
+        # `__dir__` resolves to:
+        #   dev:           lib/shared  → shared_root = lib/shared
+        #   installed gem: lib         → shared_root = lib (the impl dir is
+        #                                       merged in by the staged build, so
+        #                                       impl_root below is missing and the
+        #                                       conditional push is skipped)
+        def load(impl)
+          @impl = impl
+          shared_root = File.expand_path(__dir__)
+          impl_root = File.expand_path("../#{impl}", shared_root)
+
+          loader = Zeitwerk::Loader.new
+          loader.tag = 'neo4j-ruby-driver'
+          loader.inflector = Zeitwerk::GemInflector.new(File.expand_path('neo4j/driver', __dir__))
+          loader.inflector.inflect('packstream' => 'PackStream', 'uuid' => 'UUID')
+          loader.push_dir(shared_root)
+          loader.push_dir(impl_root) if File.directory?(impl_root)
+          yield loader if block_given?
+          # ignore the Bundler.require-friendly entry files (neo4j-ruby-driver.rb, neo4j-ruby-driver_loader.rb,
+          # neo4j_ruby_driver.rb) since Zeitwerk would otherwise try to
+          # autoload them as constants with the wrong names.
+          loader.ignore(File.expand_path(__FILE__))
+          loader.ignore(File.expand_path('neo4j-ruby-driver.rb', __dir__))
+          loader.ignore(File.expand_path('neo4j_ruby_driver.rb', __dir__))
+          loader.setup
+          loader.eager_load
+        end
+
+        def jruby? = @impl == :jruby
+
+        def mri? = @impl == :mri
       end
     end
   end