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

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(&block)
+          @segments.each(&block)
+        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,41 @@
+# 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.
+      class Relationship
+        attr_reader :id, :start_node_id, :end_node_id, :type, :properties,
+                    :element_id, :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)
+          @id = id
+          @start_node_id = start_node_id
+          @end_node_id = end_node_id
+          @type = type
+          @properties = properties
+          @element_id = element_id || id.to_s
+          @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
+
+        def [](key)
+          @properties[key.to_s] || @properties[key.to_sym]
+        end
+
+        def ==(other)
+          other.is_a?(Relationship) && other.id == @id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# 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,29 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      # Represents an unbound relationship (used in paths before binding to nodes)
+      class UnboundRelationship
+        attr_reader :id, :type, :properties, :element_id
+
+        def initialize(id, type, properties, element_id = nil)
+          @id = id
+          @type = type
+          @properties = properties
+          @element_id = element_id || id.to_s
+        end
+
+        def [](key)
+          @properties[key.to_s] || @properties[key.to_sym]
+        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.0.alpha.2'
+    VERSION = '6.2.1.beta.1'
   end
 end

data/lib/neo4j/driver.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'connection_pool'
+require 'neo4j-ruby-driver_loader'
+require 'openssl'
+require 'set'
+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