neo4j-ruby-driver 5.27.0.alpha.0-java → 6.0.1.alpha.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4064ef5d82cfd2fe300cf2d52e0a35b9ba09a8b6d5cfc868650fa3d7dafb4020
-  data.tar.gz: 99b488de69aa44cc83c9dd2a0ed3737f42653019c4f7776188c067599bae773d
+  metadata.gz: c174b6fb71a96ae78be2e140cdeb0918dac5e1afb5036a82abb067985c815ac2
+  data.tar.gz: efd9b59b2de7bc38291332ebb5eedc1af1cebb0521835e9a6735267c88ae1813
 SHA512:
-  metadata.gz: f5be2270b61637f3867c2d2bb635003e2b463e3292d2f76874ebf244ac9a1735a7f5387a7fac1d9fd2ff298181732c2f10a36482a15759734d420045cb895532
-  data.tar.gz: 8ccdb481223dc80fecdfdf596e0b10a75bb80327a143f882d30fa3ac23c118bd0c67f9f78145d4de95d97ca4ab8ce7666039763d2d0726e3b908bc911b30a391
+  metadata.gz: b5e75ea8218be1484361218a5d0300c8b9e71843bb78956cd831810c60380b9a701c63e091837e7c097ba312ba20a491d422ec830eee41e51cdb0e315760f378
+  data.tar.gz: dd15c10c93e58fce166e76a4d5820626f27edc74ff7722b0c7cfec18d84db5b1d3fe1bf8910c7e902d4b03c77ea859c6844537c30fc309d81c1e311e0e88e593

data/README.md

@@ -1,12 +1,50 @@
-# Neo4j::Driver
+# Neo4j Ruby Driver
 
-home  :: https://github.com/neo4jrb/neo4j-ruby-driver
+This repository contains 2 implementation of a Neo4j driver for Ruby:
 
-This repository contains 2 implementation of a neo4j driver for ruby:
-- based on official java implementation. It provides a thin wrapper over the java driver (only on jruby).
-- pure ruby implmementation. Available on all ruby versions >= 3.1.
+- based on official Java implementation. It provides a thin wrapper over the Java driver (only on jruby).
+- pure Ruby implementation. Available on all Ruby versions >= 3.1.
 
-## Installation
+Network communication is handled using [Bolt Protocol](https://7687.org/).
+
+<details>
+<summary>Table of Contents</summary>
+
+* [Getting started](#getting-started)
+    * [Installation](#installation)
+    * [Getting a Neo4j instance](#getting-a-neo4j-instance)
+    * [Quick start example](#quick-start-example)
+* [Server Compatibility](#server-compatibility)
+* [Usage](#usage)
+    * [Connecting to a database](#connecting-to-a-database)
+        * [URI schemes](#uri-schemes)
+        * [Authentication](#authentication)
+        * [Configuration](#configuration)
+        * [Connectivity check](#connectivity-check)
+    * [Sessions & transactions](#sessions--transactions)
+        * [Session](#session)
+        * [Auto-commit transactions](#auto-commit-transactions)
+        * [Explicit transactions](#explicit-transactions)
+        * [Read transactions](#read-transactions)
+        * [Write transactions](#write-transactions)
+    * [Working with results](#working-with-results)
+        * [Accessing Node and Relationship data](#accessing-node-and-relationship-data)
+        * [Working with Paths](#working-with-paths)
+        * [Working with temporal types](#working-with-temporal-types)
+    * [Type mapping](#type-mapping)
+    * [Advanced](#advanced)
+        * [Connection pooling](#connection-pooling)
+        * [Logging](#logging)
+* [For Driver Engineers](#for-driver-engineers)
+    * [Testing](#testing)
+* [Contributing](#contributing)
+* [License](#license)
+
+</details>
+
+## Getting started
+
+### Installation
 
 Add this line to your application's Gemfile:
 
@@ -16,68 +54,430 @@ gem 'neo4j-ruby-driver'
 
 And then execute:
 
-    $ bundle
+```bash
+bundle install
+```
 
 Or install it yourself as:
 
-    $ gem install neo4j-ruby-driver
+```bash
+gem install neo4j-ruby-driver
+```
+
+### Getting a Neo4j instance
+
+You need a running Neo4j database in order to use the driver with it. The easiest way to spin up a **local instance** is
+through a Docker container.
+
+The command below runs the latest Neo4j version in Docker, setting the admin username and password to `neo4j` and
+`password` respectively:
+
+```bash
+docker run \
+        -p7474:7474 \
+        -p7687:7687 \
+        -d \
+        -e NEO4J_AUTH=neo4j/password \
+        neo4j:latest
+```
+
+### Quick start example
+
+```ruby
+require 'neo4j/driver'
+
+Neo4j::Driver::GraphDatabase.driver(
+  'bolt://localhost:7687',
+  Neo4j::Driver::AuthTokens.basic('neo4j', 'password')
+) do |driver|
+  driver.session(database: 'neo4j') do |session|
+    query_result = session.run('RETURN 2+2 AS value')
+    puts "2+2 equals #{query_result.single['value']}"
+
+    # consume gives the execution summary
+    create_result = session.run('CREATE (n)').consume
+    puts "Nodes created: #{create_result.counters.nodes_created}"
+  end
+end
+```
 
 ## Server Compatibility
 
-The compatibility with Neo4j Server versions is documented in the [Neo4j Knowledge Base](https://neo4j.com/developer/kb/neo4j-supported-versions/).
+The compatibility with Neo4j Server versions is documented in
+the [Neo4j Knowledge Base](https://neo4j.com/developer/kb/neo4j-supported-versions/).
 
 ## Usage
 
-The API is to highest possible degree consistent with the official java driver. 
-At this moment [The Neo4j Drivers Manual v4.4](https://neo4j.com/docs/java-manual/current/) along with the ruby version of the [code fragments](https://github.com/neo4jrb/neo4j-ruby-driver/blob/master/docs/dev_manual_examples.rb) and the ruby specs provide the only documentation. 
+The API is to highest possible degree consistent with the official Java driver. Please refer to
+the [Neo4j Java Driver Manual](https://neo4j.com/docs/java-manual/current/), [examples in Ruby](https://github.com/neo4jrb/neo4j-ruby-driver/blob/master/docs/dev_manual_examples.rb),
+and code snippets below to understand how to use it.
+[Neo4j Java Driver API Docs](https://neo4j.com/docs/api/java-driver/current/) can be helpful as well.
+
+### Connecting to a database
+
+#### URI schemes
+
+The driver supports the following URI schemes:
+
+| URI Scheme     | Description                                                                     |
+|----------------|---------------------------------------------------------------------------------|
+| `neo4j://`     | Connect using routing to a cluster/causal cluster.                              |
+| `neo4j+s://`   | Same as `neo4j://` but with full TLS encryption.                                |
+| `neo4j+ssc://` | Same as `neo4j://` but with full TLS encryption, without hostname verification. |
+| `bolt://`      | Connect directly to a server using the Bolt protocol.                           |
+| `bolt+s://`    | Same as `bolt://` but with full TLS encryption.                                 |
+| `bolt+ssc://`  | Same as `bolt://` but with full TLS encryption, without hostname verification.  |
+
+Example:
+
+```ruby
+# Connect to a single instance
+driver = Neo4j::Driver::GraphDatabase.driver(
+  'bolt://localhost:7687',
+  Neo4j::Driver::AuthTokens.basic('neo4j', 'password')
+)
+
+# Connect to a cluster
+driver = Neo4j::Driver::GraphDatabase.driver(
+  'neo4j://graph.example.com:7687',
+  Neo4j::Driver::AuthTokens.basic('neo4j', 'password')
+)
+```
+
+#### Authentication
+
+The driver provides multiple authentication methods:
+
+```ruby
+# Basic authentication
+auth = Neo4j::Driver::AuthTokens.basic('neo4j', 'password')
+
+# With realm specification
+auth = Neo4j::Driver::AuthTokens.basic('neo4j', 'password', 'realm')
+
+# Kerberos authentication
+auth = Neo4j::Driver::AuthTokens.kerberos('ticket')
+
+# Bearer authentication
+auth = Neo4j::Driver::AuthTokens.bearer('token')
+
+# Custom authentication
+auth = Neo4j::Driver::AuthTokens.custom('principal', 'credentials', 'realm', 'scheme')
+
+# No authentication
+auth = Neo4j::Driver::AuthTokens.none
+```
+
+#### Configuration
+
+You can configure the driver with additional options:
+
+```ruby
+config = {
+  connection_timeout: 15.seconds,
+  connection_acquisition_timeout: 1.minute,
+  max_transaction_retry_time: 30.seconds,
+  encryption: true,
+  trust_strategy: :trust_all_certificates
+}
+
+driver = Neo4j::Driver::GraphDatabase.driver(
+  'neo4j://localhost:7687',
+  Neo4j::Driver::AuthTokens.basic('neo4j', 'password'),
+  **config
+)
+```
+
+#### Connectivity check
+
+```ruby
+if driver.verify_connectivity
+  puts "Driver is connected to the database"
+else
+  puts "Driver cannot connect to the database"
+end
+```
+
+### Sessions & transactions
+
+The driver provides sessions to interact with the database and to execute queries.
+
+#### Session
+
+Sessions are lightweight and disposable database connections. Always close your sessions when done:
+
+```ruby
+session = driver.session(database: 'neo4j')
+begin
+  session.run('MATCH (n) RETURN n LIMIT 10')
+ensure
+  session.close
+end
+```
+
+Or use a block that automatically closes the session:
+
+```ruby
+driver.session(database: 'neo4j') do |session|
+  session.run('MATCH (n) RETURN n LIMIT 10')
+end
+```
+
+Session options:
+
+```ruby
+# Default database
+session = driver.session
+
+# Specific database
+session = driver.session(database: 'neo4j')
+
+# With access mode
+session = driver.session(database: 'neo4j', default_access_mode: Neo4j::Driver::AccessMode::READ)
+
+# With bookmarks for causal consistency
+session = driver.session(
+  database: 'neo4j',
+  bookmarks: [Neo4j::Driver::Bookmark.from('bookmark-1')]
+)
+```
+
+#### Auto-commit transactions
+
+For simple, one-off queries, use auto-commit transactions:
+
+```ruby
+session.run('CREATE (n:Person {name: $name})', name: 'Alice')
+```
+
+#### Explicit transactions
+
+For multiple queries that need to be executed as a unit, use explicit transactions:
+
+```ruby
+tx = session.begin_transaction
+begin
+  tx.run('CREATE (n:Person {name: $name})', name: 'Alice')
+  tx.run('CREATE (n:Person {name: $name})', name: 'Bob')
+  tx.commit
+rescue
+  tx.rollback
+  raise
+end
+```
+
+#### Read transactions
+
+Specifically for read operations:
+
+```ruby
+result = session.read_transaction do |tx|
+  tx.run('MATCH (n:Person) RETURN n.name').map { |record| record['n.name'] }
+end
+puts result
+```
+
+#### Write transactions
+
+Specifically for write operations:
+
+```ruby
+session.write_transaction do |tx|
+  tx.run('CREATE (n:Person {name: $name})', name: 'Charlie')
+end
+```
+
+### Working with results
+
+```ruby
+result = session.run('MATCH (n:Person) RETURN n.name AS name, n.age AS age')
+
+# Process results
+result.each do |record|
+  puts "#{record['name']} is #{record['age']} years old"
+end
+
+# Check if there are more results
+puts "Has more results: #{result.has_next?}"
+
+# Get a single record
+single = result.single
+puts single['name'] if single
+
+# Get keys available in the result
+puts "Keys: #{result.keys}"
+
+# Access by field index
+result.each do |record|
+  puts "First field: #{record[0]}"
+end
+
+# Convert to array
+records = result.to_a
+```
+
+#### Accessing Node and Relationship data
+
+Working with graph entities:
+
+```ruby
+result = session.run('MATCH (p:Person)-[r:KNOWS]->(friend) RETURN p, r, friend')
+
+result.each do |record|
+  # Working with nodes
+  person = record['p']
+  puts "Node ID: #{person.id}"
+  puts "Labels: #{person.labels.join(', ')}"
+  puts "Properties: #{person.properties}"
+  puts "Name property: #{person.properties['name']}"
+
+  # Working with relationships
+  relationship = record['r']
+  puts "Relationship ID: #{relationship.id}"
+  puts "Type: #{relationship.type}"
+  puts "Properties: #{relationship.properties}"
+
+  # Start and end nodes of the relationship
+  puts "Relationship: #{relationship.start_node_id} -> #{relationship.end_node_id}"
+end
+```
+
+#### Working with Paths
+
+Processing paths returned from Cypher:
+
+```ruby
+result = session.run('MATCH p = (:Person)-[:KNOWS*]->(:Person) RETURN p')
+
+result.each do |record|
+  path = record['p']
+
+  # Get all nodes in the path
+  nodes = path.nodes
+  puts "Nodes in path: #{nodes.map { |n| n.properties['name'] }.join(' -> ')}"
+
+  # Get all relationships in the path
+  relationships = path.relationships
+  puts "Relationship types: #{relationships.map(&:type).join(', ')}"
+
+  # Iterate through the path segments
+  path.each do |segment|
+    puts "#{segment.start_node.properties['name']} -[#{segment.relationship.type}]-> #{segment.end_node.properties['name']}"
+  end
+end
+```
+
+#### Working with temporal types
+
+Creating a node with properties of temporal types:
+
+```ruby
+session.run(
+  'CREATE (e:Event {datetime: $datetime, duration: $duration})',
+  datetime: DateTime.new(2025, 5, 5, 5, 55, 55), duration: 1.hour
+)
+```
+
+Querying temporal values:
+
+```ruby
+session.run('MATCH (e:Event) LIMIT 1 RETURN e.datetime, e.duration').single.to_h
+# => {"e.datetime": 2025-05-05 05:55:55 +0000, "e.duration": 3600 seconds}
+```
+
+### Type mapping
 
-[Neo4j Java Driver 4.3 API](https://neo4j.com/docs/api/java-driver/current/) can be helpful as well..
+The Neo4j Ruby Driver maps Cypher types to Ruby types:
 
-## Development
+| Cypher Type    | Ruby Type                                     |
+|----------------|-----------------------------------------------|
+| null           | nil                                           |
+| List           | Enumerable                                    |
+| Map            | Hash (symbolized keys)                        |
+| Boolean        | TrueClass/FalseClass                          |
+| Integer        | Integer/String[^1]                            |
+| Float          | Float                                         |
+| String         | String/Symbol[^2] (encoding: UTF-8)           |
+| ByteArray      | String (encoding: BINARY)                     |
+| Date           | Date                                          |
+| Zoned Time     | Neo4j::Driver::Types::OffsetTime              |
+| Local Time     | Neo4j::Driver::Types::LocalTime               |
+| Zoned DateTime | Time/ActiveSupport::TimeWithZone/DateTime[^3] |
+| Local DateTime | Neo4j::Driver::Types::LocalDateTime           |
+| Duration       | ActiveSupport::Duration                       |
+| Point          | Neo4j::Driver::Types::Point                   |
+| Node           | Neo4j::Driver::Types::Node                    |
+| Relationship   | Neo4j::Driver::Types::Relationship            |
+| Path           | Neo4j::Driver::Types::Path                    |
 
-This gem includes 2 different implementations: java driver wrapper and pure ruby driver
+[^1]: An Integer smaller than -2 ** 63 or larger than 2 ** 63 will always be implicitly converted to String
+[^2]: A Symbol passed as a parameter will always be implicitly converted to String. All Strings other than BINARY
+encoded are converted to UTF-8 when stored in Neo4j
+[^3]: A Ruby DateTime passed as a parameter will always be implicitly converted to Time
 
-    $ bin/setup 
-     
-## Testing
+### Advanced
 
-To run the tests the following tools need to be installed:
+#### Connection pooling
 
-    $ brew install python
-    $ pip3 install --user git+https://github.com/klobuczek/boltkit@1.3#egg=boltkit
-    $ neoctrl-install -e 4.4.5 servers
-    $ neoctrl-configure servers/neo4j-enterprise-4.4.5 dbms.directories.import= dbms.default_listen_address=::
-    $ neoctrl-set-initial-password pass servers/neo4j-enterprise-4.4.5
-    $ neoctrl-start servers/neo4j-enterprise-4.4.5
+The driver handles connection pooling automatically. Configure the connection pool:
+
+```ruby
+config = {
+  max_connection_pool_size: 100,
+  max_connection_lifetime: 1.hour
+}
 
-To run the tests:
-```console
-$ bin/setup
-$ rspec spec
+driver = Neo4j::Driver::GraphDatabase.driver('neo4j://localhost:7687', auth, **config)
 ```
 
-Known errors:
+#### Logging
 
-1. In case of heap space memory error (`org.neo4j.driver.exceptions.DatabaseException: Java heap space`), you should limit the dbms memory, for example:
+Configure logging for the driver:
 
-```console
-$ neoctrl-configure servers/neo4j-enterprise-4.4.5 dbms.memory.pagecache.size=600m dbms.memory.heap.max_size=600m dbms.memory.heap.initial_size=600m dbms.directories.import= dbms.connectors.default_listen_address=::
+```ruby
+config = {
+  logger: Logger.new(STDOUT).tap { |log| log.level = Logger::DEBUG }
+}
+
+driver = Neo4j::Driver::GraphDatabase.driver('neo4j://localhost:7687', auth, **config)
 ```
 
-2. When using command `pip3 install --user git+https://github.com/klobuczek/boltkit@1.3#egg=boltkit`, if you have m1 mac chip, you may get error when pip3 tries to install `cryptography`. Steps to take in that case (reference https://stackoverflow.com/a/70074869/2559490)
+## For Driver Engineers
 
-```console
-$ pip uninstall cffi
-$ python -m pip install --upgrade pip
-$ pip install cffi
-$ pip install cryptography
+This gem includes 2 different implementations: a Java driver wrapper and a pure Ruby driver, so you will have to run
+this command every time you switch the Ruby engine:
+
+```bash
+bin/setup
 ```
 
+### Testing
+
+There are two sets of tests for the driver. To run the specs placed in this repository, use a normal rspec command:
+
+```bash
+rspec spec
+```
+
+To run the [Testkit](https://github.com/neo4j-drivers/testkit) that is used to test all Neo4j driver implementations,
+use the following:
+
+```bash
+git clone git@github.com:neo4j-drivers/testkit.git
+cd testkit
+export TEST_DRIVER_NAME=ruby
+export TEST_DRIVER_REPO=`realpath ../neo4j-ruby-driver`
+export TEST_NEO4J_PASS=password
+python3 main.py --tests UNIT_TESTS --configs 4.3-enterprise
+```
+
+Please refer to the [Testkit](https://github.com/neo4j-drivers/testkit) documentation to learn more about its features.
+
 ## Contributing
 
-Suggestions, improvements, bug reports and pull requests are welcome on GitHub at https://github.com/neo4jrb/neo4j-ruby-driver.
+Suggestions, improvements, bug reports and pull requests are welcome on GitHub
+at https://github.com/neo4jrb/neo4j-ruby-driver.
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-

data/jruby/neo4j/driver/ext/config_converter.rb

@@ -68,14 +68,14 @@ module Neo4j
 
         def notification_config(minimum_severity: nil, disabled_categories: nil)
           org.neo4j.driver.internal.InternalNotificationConfig.new(
-            value_of(org.neo4j.driver.internal.InternalNotificationSeverity, minimum_severity),
+            value_of(org.neo4j.driver.internal.InternalNotificationSeverity, minimum_severity).or_else(nil),
             disabled_categories
-              &.map { |value| value_of(org.neo4j.driver.internal.InternalNotificationCategory, value) }
+              &.map { |value| value_of(org.neo4j.driver.NotificationClassification, value) }
               &.then(&java.util.HashSet.method(:new)))
         end
 
         def value_of(klass, value)
-          klass.value_of(value&.to_s&.upcase).or_else(nil)
+          klass.value_of(value&.to_s&.upcase)
         end
       end
     end

data/jruby/neo4j/driver/ext/delegating_transaction_context.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module DelegatingTransactionContext
+        include ExceptionCheckable
+        include RunOverride
+
+        def run(statement, **parameters)
+          check { super(to_statement(statement, parameters)) }
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/graph_database.rb

@@ -4,11 +4,11 @@ module Neo4j
   module Driver
     module Ext
       module GraphDatabase
-        extend AutoClosable
+        extend AutoCloseable
         include ConfigConverter
         include ExceptionCheckable
 
-        auto_closable :driver
+        auto_closeable :driver
 
         def driver(uri, auth_token = Neo4j::Driver::AuthTokens.none, **config)
           check do

data/jruby/neo4j/driver/ext/internal/cluster/routing_table_registry_impl.rb

@@ -5,7 +5,7 @@ module Neo4j::Driver::Ext
     module Cluster
       module RoutingTableRegistryImpl
         def routing_table_handler(database)
-          get_routing_table_handler(org.neo4j.driver.internal.bolt.api.DatabaseNameUtil.database(database)).then do |it|
+          get_routing_table_handler(org.neo4j.driver.internal.bolt.api.DatabaseName.database(database)).then do |it|
             it.get if it.present?
           end
         end

data/jruby/neo4j/driver/ext/internal/eager_result_value.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module EagerResultValue
+          include InternalKeys
+
+          def records
+            super.to_a
+          end
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal_driver.rb

@@ -4,12 +4,22 @@ module Neo4j
   module Driver
     module Ext
       module InternalDriver
-        extend AutoClosable
+        extend AutoCloseable
         include ConfigConverter
         include ExceptionCheckable
         include AsyncConverter
 
-        auto_closable :session
+        auto_closeable :session
+
+        def execute_query(query, auth_token = nil, config = {}, **parameters)
+          check do
+            executable_query(query)
+              .with_auth_token(auth_token)
+              .with_config(to_java_config(Neo4j::Driver::QueryConfig, **config))
+              .with_parameters(to_neo(parameters))
+              .execute
+          end
+        end
 
         def session(**session_config)
           java_method(:session, [org.neo4j.driver.SessionConfig])

data/jruby/neo4j/driver/ext/internal_session.rb

@@ -4,18 +4,18 @@ module Neo4j
   module Driver
     module Ext
       module InternalSession
-        extend AutoClosable
+        extend AutoCloseable
         include ConfigConverter
         include ExceptionCheckable
         include RunOverride
 
-        auto_closable :begin_transaction
+        auto_closeable :begin_transaction
 
         # work around jruby issue https://github.com/jruby/jruby/issues/5603
         Struct.new('Wrapper', :object)
 
-        %i[read write].each do |prefix|
-          define_method("#{prefix}_transaction") do |**config, &block|
+        %i[read write].each do |mode|
+          define_method("execute_#{mode}") do |**config, &block|
             check do
               super(->(tx) { Struct::Wrapper.new(reverse_check { block.call(tx) }) }, to_java_config(Neo4j::Driver::TransactionConfig, **config)).object
             end
@@ -34,6 +34,10 @@ module Neo4j
         def begin_transaction(**config)
           check { super(to_java_config(Neo4j::Driver::TransactionConfig, **config)) }
         end
+
+        def last_bookmarks
+          super.to_set
+        end
       end
     end
   end

data/jruby/neo4j/driver/version.rb

@@ -2,6 +2,6 @@
 
 module Neo4j
   module Driver
-    VERSION = '5.27.0.alpha.0'
+    VERSION = '6.0.1.alpha.0'
   end
 end

data/jruby/neo4j/driver.rb

@@ -10,12 +10,13 @@ module Neo4j
 
     include_package 'org.neo4j.driver'
 
+    EagerResult = Java::OrgNeo4jDriverInternal::EagerResultValue
     Record = Java::OrgNeo4jDriverInternal::InternalRecord
     Result = Java::OrgNeo4jDriverInternal::InternalResult
     Transaction = Java::OrgNeo4jDriverInternal::InternalTransaction
 
     module Internal
-      java_import org.neo4j.driver.internal.bolt.api.DatabaseNameUtil
+      java_import org.neo4j.driver.internal.shaded.bolt.connection.DatabaseName
     end
 
     module Net
@@ -36,10 +37,9 @@ module Neo4j
 end
 
 Java::OrgNeo4jDriver::AuthTokens.singleton_class.prepend Neo4j::Driver::Ext::AuthTokens
-Java::OrgNeo4jDriver::Bookmark.singleton_class.prepend Neo4j::Driver::Ext::Bookmark::ClassMethods
 Java::OrgNeo4jDriver::GraphDatabase.singleton_class.prepend Neo4j::Driver::Ext::GraphDatabase
 Java::OrgNeo4jDriver::Query.prepend Neo4j::Driver::Ext::Query
-Java::OrgNeo4jDriverInternal::InternalBookmark.prepend Neo4j::Driver::Ext::Internal::InternalBookmark
+Java::OrgNeo4jDriverInternal::EagerResultValue.prepend Neo4j::Driver::Ext::Internal::EagerResultValue
 Java::OrgNeo4jDriverInternal::InternalDriver.prepend Neo4j::Driver::Ext::InternalDriver
 Java::OrgNeo4jDriverInternal::InternalEntity.include Neo4j::Driver::Ext::InternalEntity
 Java::OrgNeo4jDriverInternal::InternalNode.prepend Neo4j::Driver::Ext::InternalNode
@@ -51,10 +51,11 @@ Java::OrgNeo4jDriverInternal::InternalRelationship.prepend Neo4j::Driver::Ext::I
 Java::OrgNeo4jDriverInternal::InternalResult.prepend Neo4j::Driver::Ext::InternalResult
 Java::OrgNeo4jDriverInternal::InternalSession.prepend Neo4j::Driver::Ext::InternalSession
 Java::OrgNeo4jDriverInternal::InternalTransaction.prepend Neo4j::Driver::Ext::InternalTransaction
+Java::OrgNeo4jDriverInternal::DelegatingTransactionContext.prepend Neo4j::Driver::Ext::DelegatingTransactionContext
 Java::OrgNeo4jDriverInternalAsync::InternalAsyncSession.prepend Neo4j::Driver::Ext::Internal::Async::InternalAsyncSession
-Java::OrgNeo4jDriverInternalBoltRoutedimplCluster::RoutingTableRegistryImpl.include Neo4j::Driver::Ext::Internal::Cluster::RoutingTableRegistryImpl
+Java::OrgNeo4jDriverInternalShadedBoltConnectionRoutedImplCluster::RoutingTableRegistryImpl.include Neo4j::Driver::Ext::Internal::Cluster::RoutingTableRegistryImpl
 # Java::OrgNeo4jDriverInternalCursor::DisposableAsyncResultCursor.prepend Neo4j::Driver::Ext::Internal::Cursor::DisposableAsyncResultCursor
-Java::OrgNeo4jDriverInternalMetrics::InternalConnectionPoolMetrics.include Neo4j::Driver::Ext::Internal::Metrics::InternalConnectionPoolMetrics
+Java::OrgNeo4jDriverObservationMetricsInternal::InternalConnectionPoolMetrics.include Neo4j::Driver::Ext::Internal::Metrics::InternalConnectionPoolMetrics
 Java::OrgNeo4jDriverInternalSummary::InternalNotification.prepend Neo4j::Driver::Ext::Internal::Summary::InternalNotification
 Java::OrgNeo4jDriverInternalSummary::InternalPlan.prepend Neo4j::Driver::Ext::Internal::Summary::InternalPlan
 Java::OrgNeo4jDriverInternalSummary::InternalResultSummary.prepend Neo4j::Driver::Ext::Internal::Summary::InternalResultSummary

data/lib/neo4j/driver/{auto_closable.rb → auto_closeable.rb}

@@ -2,8 +2,8 @@
 
 module Neo4j
   module Driver
-    module AutoClosable
-      def auto_closable(*methods)
+    module AutoCloseable
+      def auto_closeable(*methods)
         prepend with_block_definer(methods)
       end
 
@@ -13,15 +13,15 @@ module Neo4j
         Module.new do
           methods.each do |method|
             define_method(method) do |*args, **kwargs, &block|
-              closable = super(*args, **kwargs)
+              closeable = super(*args, **kwargs)
               if block
                 begin
-                  block.arity.zero? ? closable.instance_eval(&block) : block.call(closable)
+                  block.arity.zero? ? closeable.instance_eval(&block) : block.call(closeable)
                 ensure
-                  closable&.close
+                  closeable&.close
                 end
               else
-                closable
+                closeable
               end
             end
           end

data/lib/neo4j/driver/internal/deprecator.rb

@@ -0,0 +1,15 @@
+module Neo4j
+  module Driver
+    module Internal
+      module Deprecator
+        def self.deprecator
+          @deprecator ||= ActiveSupport::Deprecation.new('6.0', 'neo4j-ruby-driver')
+        end
+
+        def self.log_warning(old_method, new_method, version)
+          deprecator.deprecation_warning(old_method, new_method)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-ruby-driver
 version: !ruby/object:Gem::Version
-  version: 5.27.0.alpha.0
+  version: 6.0.1.alpha.0
 platform: java
 authors:
 - Heinrich Klobuczek
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +69,16 @@ dependencies:
   name: jar-dependencies
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.1
+        version: 0.5.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.1
+        version: 0.5.5
 - !ruby/object:Gem::Dependency
   name: ffaker
   requirement: !ruby/object:Gem::Requirement
@@ -226,8 +239,8 @@ files:
 - jruby/neo4j/driver.rb
 - jruby/neo4j/driver/ext/async_converter.rb
 - jruby/neo4j/driver/ext/auth_tokens.rb
-- jruby/neo4j/driver/ext/bookmark.rb
 - jruby/neo4j/driver/ext/config_converter.rb
+- jruby/neo4j/driver/ext/delegating_transaction_context.rb
 - jruby/neo4j/driver/ext/exception_checkable.rb
 - jruby/neo4j/driver/ext/exception_mapper.rb
 - jruby/neo4j/driver/ext/graph_database.rb
@@ -235,7 +248,7 @@ files:
 - jruby/neo4j/driver/ext/internal/cluster/routing_table_registry_impl.rb
 - jruby/neo4j/driver/ext/internal/cursor/disposable_async_result_cursor.rb
 - jruby/neo4j/driver/ext/internal/driver_factory.rb
-- jruby/neo4j/driver/ext/internal/internal_bookmark.rb
+- jruby/neo4j/driver/ext/internal/eager_result_value.rb
 - jruby/neo4j/driver/ext/internal/metrics/internal_connection_pool_metrics.rb
 - jruby/neo4j/driver/ext/internal/summary/internal_notification.rb
 - jruby/neo4j/driver/ext/internal/summary/internal_plan.rb
@@ -259,7 +272,7 @@ files:
 - jruby/neo4j/driver/version.rb
 - lib/neo4j-ruby-driver.rb
 - lib/neo4j-ruby-driver_loader.rb
-- lib/neo4j/driver/auto_closable.rb
+- lib/neo4j/driver/auto_closeable.rb
 - lib/neo4j/driver/exceptions/authentication_exception.rb
 - lib/neo4j/driver/exceptions/authorization_expired_exception.rb
 - lib/neo4j/driver/exceptions/certificate_exception.rb
@@ -287,6 +300,7 @@ files:
 - lib/neo4j/driver/exceptions/value/unsizable.rb
 - lib/neo4j/driver/exceptions/value/value_exception.rb
 - lib/neo4j/driver/internal/bolt_server_address.rb
+- lib/neo4j/driver/internal/deprecator.rb
 - lib/neo4j/driver/internal/duration_normalizer.rb
 - lib/neo4j/driver/internal/validator.rb
 - lib/neo4j/driver/summary/query_type.rb
@@ -302,7 +316,6 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/neo4jrb/neo4j-ruby-driver
-post_install_message:
 rdoc_options:
 - "--main"
 - README.md
@@ -316,13 +329,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements:
-- jar org.neo4j.driver, neo4j-java-driver-all, 5.27.0
-rubygems_version: 3.3.26
-signing_key:
+- jar org.neo4j.driver, neo4j-java-driver-all, 6.0.1
+- jar org.neo4j.driver, neo4j-java-driver-observation-metrics, 6.0.1
+rubygems_version: 3.6.9
 specification_version: 4
 summary: ''
 test_files: []

data/jruby/neo4j/driver/ext/bookmark.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Ext
-      module Bookmark
-        module ClassMethods
-          def from(*values)
-            super(java.util.HashSet.new(values))
-          end
-        end
-      end
-    end
-  end
-end

data/jruby/neo4j/driver/ext/internal/internal_bookmark.rb

@@ -1,13 +0,0 @@
-module Neo4j
-  module Driver
-    module Ext
-      module Internal
-        module InternalBookmark
-          def values
-            super.to_set
-          end
-        end
-      end
-    end
-  end
-end