neo4j-ruby-driver 6.2.1.beta.1-java → 6.2.1.beta.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e969dbfe25cfa1cb001437b4ac6fd6e203ddc9f5d4a928ebd2dc3834641e66f7
-  data.tar.gz: 0cb98f41691ad780890aafc34c63d7a614adc8bcbb8cd0e298686452e6340d25
+  metadata.gz: 8c23247c73132c7a801d9c4236df0e5ec06f7f89ca62e6a4bb5b5613a9ba0ca9
+  data.tar.gz: ad8bff687e3c0429cc26cc4c3663a7fcceb63f9c32c362dcb9a2cc968d416b38
 SHA512:
-  metadata.gz: 3383e63f2b5fcc83f6102bb82c98fdaeeadc6148339a59c4184e2af06dbb609a5c98ab0e3e365effcbc1afebdf13859b7de75e2ad1ce9880b3a43b1a2bccdc60
-  data.tar.gz: 18c124b05a3b5cc24d877f357caba8d68abd3b62156f8fea0a228e1b8d0e14c0db54df49d7b53f43f72a1b4d7ea853e06d802b13cf807a9844f2a6e293f6afd1
+  metadata.gz: e13cba51cf61aa2cf912d6cbf404acd8cd016e7d26aafbb50b89b988d30611e5e6b33ce22d1f786350389dc53730db535c92dc66fe94110e1a9dc7e892814094
+  data.tar.gz: 293189542dd4e549f20aaf0641734d677f94b12b6e323a07912e0c4d3caf08fa4d4706431b50a9e696ce3abbfc00ba7843e1f6499739760a00c2534fbc20ebcd

data/lib/neo4j/driver/exceptions/no_such_record_exception.rb

@@ -6,7 +6,7 @@ module Neo4j
       class NoSuchRecordException < RuntimeError
         EMPTY = 'Cannot retrieve a single record, because this result is empty.'
         TOO_MANY = 'Expected a result with a single record, but this result ' \
-          'contains at least one more. Ensure your query returns only one record.'
+                   'contains at least one more. Ensure your query returns only one record.'
         NO_MORE = 'No more records'
         NO_PEEK_PAST = 'Cannot peek past the last record'
 

data/lib/neo4j/driver/ext/bookmark_managers.rb

@@ -12,7 +12,8 @@ module Neo4j
         include ConfigConverter
 
         def default_manager(initial_bookmarks: nil, bookmarks_supplier: nil, bookmarks_consumer: nil)
-          super(to_java_config(Neo4j::Driver::BookmarkManagerConfig, initial_bookmarks:, bookmarks_supplier:, bookmarks_consumer:))
+          super(to_java_config(Neo4j::Driver::BookmarkManagerConfig, initial_bookmarks:, bookmarks_supplier:,
+                                                                     bookmarks_consumer:))
         end
       end
     end

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

@@ -50,7 +50,7 @@ module Neo4j
             value = ->(address) { to_java_set(proc.call(address), java.util.LinkedHashSet) }
           when 'bookmarks_supplier'
             proc = value
-            value = ->() { to_java_set(proc.call) }
+            value = -> { to_java_set(proc.call) }
           when 'bookmarks_consumer'
             proc = value
             value = ->(bookmarks) { proc.call(Set.new(bookmarks)) }
@@ -85,7 +85,7 @@ module Neo4j
             case strategy
             when :trust_custom_certificates
               Config::TrustStrategy
-                .trust_custom_certificate_signed_by(*config.delete(:cert_files).map(&java.io.File.method(:new)))
+            .trust_custom_certificate_signed_by(*config.delete(:cert_files).map(&java.io.File.method(:new)))
             else
               Config::TrustStrategy.send(strategy)
             end
@@ -97,7 +97,8 @@ module Neo4j
             value_of(org.neo4j.driver.internal.InternalNotificationSeverity, minimum_severity).or_else(nil),
             disabled_categories
               &.map { |value| value_of(org.neo4j.driver.NotificationClassification, value) }
-              &.then(&method(:to_java_set)))
+              &.then(&method(:to_java_set))
+          )
         end
 
         def value_of(klass, value)

data/lib/neo4j/driver/ext/exception_checkable.rb

@@ -17,9 +17,9 @@ module Neo4j
         rescue Neo4j::Driver::Exceptions::ServiceUnavailableException => e
           raise(throwable(e.cause) || Java::OrgNeo4jDriverExceptions::ServiceUnavailableException.new(e.message))
         rescue Neo4j::Driver::Exceptions::Neo4jException,
-          Neo4j::Driver::Exceptions::NoSuchRecordException,
-          Neo4j::Driver::Exceptions::UntrustedServerException,
-          Neo4j::Driver::Exceptions::IllegalStateException => e
+               Neo4j::Driver::Exceptions::NoSuchRecordException,
+               Neo4j::Driver::Exceptions::UntrustedServerException,
+               Neo4j::Driver::Exceptions::IllegalStateException => e
           raise(throwable(e.cause) || e)
         end
 

data/lib/neo4j/driver/ext/exception_mapper.rb

@@ -152,8 +152,6 @@ module Neo4j
             Neo4j::Driver::Exceptions::TransientException
           when Neo4jException # base — catches plain GQL-cause exceptions (must be last)
             Neo4j::Driver::Exceptions::Neo4jException
-          else
-            nil
           end
         end
 
@@ -167,8 +165,6 @@ module Neo4j
             Neo4j::Driver::Exceptions::IllegalStateException
           when Java::JavaLang::IllegalArgumentException
             ArgumentError
-          else
-            nil
           end
         end
       end

data/lib/neo4j/driver/ext/internal/driver_factory.rb

@@ -26,7 +26,7 @@ module Neo4j
           def to_domain_name_resolver(resolver_proc)
             return nil unless resolver_proc
 
-            ->(name) do
+            lambda do |name|
               resolver_proc.call(name).map do |addr|
                 java.net.InetAddress.get_by_name(addr)
               rescue java.net.UnknownHostException => e

data/lib/neo4j/driver/ext/internal/internal_notification_severity.rb

@@ -6,6 +6,7 @@ module Neo4j
       module Internal
         module InternalNotificationSeverity
           extend Forwardable
+
           delegate name: :type
         end
       end

data/lib/neo4j/driver/ext/internal/summary/internal_result_summary.rb

@@ -30,9 +30,9 @@ module Neo4j
             # would be to disambiguate this one method.
             def query_type
               case super
-              when Java::OrgNeo4jDriverSummary::QueryType::READ_ONLY    then Driver::Summary::QueryType::READ_ONLY
-              when Java::OrgNeo4jDriverSummary::QueryType::READ_WRITE   then Driver::Summary::QueryType::READ_WRITE
-              when Java::OrgNeo4jDriverSummary::QueryType::WRITE_ONLY   then Driver::Summary::QueryType::WRITE_ONLY
+              when Java::OrgNeo4jDriverSummary::QueryType::READ_ONLY then Driver::Summary::QueryType::READ_ONLY
+              when Java::OrgNeo4jDriverSummary::QueryType::READ_WRITE then Driver::Summary::QueryType::READ_WRITE
+              when Java::OrgNeo4jDriverSummary::QueryType::WRITE_ONLY then Driver::Summary::QueryType::WRITE_ONLY
               when Java::OrgNeo4jDriverSummary::QueryType::SCHEMA_WRITE then Driver::Summary::QueryType::SCHEMA_WRITE
               end
             end

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

@@ -88,7 +88,8 @@ module Neo4j
           source = Internal::Reflection.field(session_factory, 'connectionSource')
           until Internal::Reflection.field?(source, 'registry')
             unless Internal::Reflection.field?(source, 'delegate')
-              raise KeyError, "No routing-table registry in the connection-source chain (#{source.java_class.simple_name})"
+              raise KeyError,
+                    "No routing-table registry in the connection-source chain (#{source.java_class.simple_name})"
             end
 
             source = Internal::Reflection.field(source, 'delegate')

data/lib/neo4j/driver/ext/internal_result.rb

@@ -14,8 +14,8 @@ module Neo4j
           end
         end
 
-        def each(&block)
-          check { stream.for_each(&block) }
+        def each(&)
+          check { stream.for_each(&) }
         end
 
         def to_a

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

@@ -17,7 +17,11 @@ module Neo4j
         %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
+              super(lambda { |tx|
+                Struct::Wrapper.new(reverse_check do
+                                      block.call(tx)
+                                    end)
+              }, to_java_config(Neo4j::Driver::TransactionConfig, **config)).object
             end
           end
         end

data/lib/neo4j/driver/ext/logger.rb

@@ -19,13 +19,13 @@ module Neo4j
         end
         alias get_log getLog
 
-        def error(*args) = log(::Logger::ERROR, *args)
+        def error(*) = log(::Logger::ERROR, *)
 
-        def info(*args) = log(::Logger::INFO, *args)
+        def info(*) = log(::Logger::INFO, *)
 
-        def warn(*args) = log(::Logger::WARN, *args)
+        def warn(*) = log(::Logger::WARN, *)
 
-        def debug(*args) = log(::Logger::DEBUG, *args)
+        def debug(*) = log(::Logger::DEBUG, *)
         alias trace debug
 
         def trace_enabled?
@@ -38,12 +38,13 @@ module Neo4j
 
         private
 
-        def log(level, *args)
-          @logger.add(level) { format(*args) }
+        def log(level, *)
+          @logger.add(level) { format(*) }
         end
 
         def format(message, *args)
           return message.to_s if args.empty? && !message.is_a?(java.lang.Throwable)
+
           args.unshift(message)
           args.unshift('%s%n%s') if args.last.is_a?(java.lang.Throwable)
           java.lang.String.format(*args)

data/lib/neo4j/driver/ext/neo_converter.rb

@@ -42,11 +42,10 @@ module Neo4j
           when nil, true, false, Integer, Float
             object
           else
-            if skip_unknown
-              object
-            else
-              raise Exceptions::ClientException.unable_to_convert(object)
-            end
+            raise Exceptions::ClientException.unable_to_convert(object) unless skip_unknown
+
+            object
+
           end
         end
 

data/lib/neo4j/driver/ext/ruby_converter.rb

@@ -45,7 +45,7 @@ module Neo4j
         def to_time
           time = as_zoned_date_time
           zone_id = time.zone.id
-          if /^Z|[+\-][0-9]{2}:[0-9]{2}$/.match?(zone_id)
+          if /^Z|[+-][0-9]{2}:[0-9]{2}$/.match?(zone_id)
             Time.parse(time.to_string)
           else
             instant = time.to_instant

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

@@ -14,8 +14,10 @@ module Neo4j
           # Check the sign before rounding: a tiny negative timeout
           # (e.g. -0.4ms) would otherwise round to 0 and slip through.
           ms = timeout.to_f * 1000
-          raise Exceptions::ClientException,
-                "Transaction timeout must not be negative, but was #{ms}ms" if ms.negative?
+          if ms.negative?
+            raise Exceptions::ClientException,
+                  "Transaction timeout must not be negative, but was #{ms}ms"
+          end
 
           ms.round
         end

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

@@ -16,6 +16,7 @@ module Neo4j
 
         def self.require_non_nil!(obj, message = nil)
           raise ArgumentError, [message, "can't be nil"].compact.join(' ') if obj.nil?
+
           obj
         end
 
@@ -24,14 +25,17 @@ module Neo4j
         # object carries its own text, so only bare strings are checked.
         def self.require_query_text!(query)
           raise ArgumentError, 'Cypher query text should not be null' if query.nil?
-          raise ArgumentError, 'Cypher query text should not be an empty string' if query.is_a?(String) && query.strip.empty?
+          if query.is_a?(String) && query.strip.empty?
+            raise ArgumentError,
+                  'Cypher query text should not be an empty string'
+          end
 
           query
         end
 
         def self.require_non_nil_credentials!(username, password)
-          require_non_nil! username, "Username"
-          require_non_nil! password, "Password"
+          require_non_nil! username, 'Username'
+          require_non_nil! password, 'Password'
         end
       end
     end

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

@@ -25,12 +25,12 @@ module Neo4j
             raise ArgumentError, "Invalid ISO 8601 duration format: #{string}"
           end
 
-          years = ($1 || 0).to_i
-          months = ($2 || 0).to_i
-          days = ($3 || 0).to_i
-          hours = ($4 || 0).to_i
-          minutes = ($5 || 0).to_i
-          seconds_with_fraction = ($6 || 0).to_f
+          years = (::Regexp.last_match(1) || 0).to_i
+          months = (::Regexp.last_match(2) || 0).to_i
+          days = (::Regexp.last_match(3) || 0).to_i
+          hours = (::Regexp.last_match(4) || 0).to_i
+          minutes = (::Regexp.last_match(5) || 0).to_i
+          seconds_with_fraction = (::Regexp.last_match(6) || 0).to_f
 
           total_months = years * 12 + months
           whole_seconds = seconds_with_fraction.to_i

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

@@ -3,11 +3,17 @@
 module Neo4j
   module Driver
     module Types
-      # Bolt LocalDateTime — wall-clock datetime without timezone.
-      # Stored as the wire-format pair (epoch_seconds, nanoseconds), where
-      # epoch_seconds is the wall-clock components encoded as if they were
-      # UTC. Two LocalDateTimes representing the same wall-clock value
-      # always have the same field values regardless of the host TZ.
+      # Bolt LocalDateTime — a wall-clock datetime with no timezone
+      # (java.time.LocalDateTime). Stored as the wire-format pair
+      # (epoch_seconds, nanoseconds), where epoch_seconds encodes the
+      # wall-clock components as if they were UTC — so the value reads the
+      # same regardless of the host TZ.
+      #
+      # There is deliberately no #to_time: a zone-less value cannot become a
+      # zoned Ruby Time without inventing a zone, and every serious datetime
+      # library refuses that implicit conversion (Java's LocalDateTime forces
+      # .atZone/.atOffset; Python yields a naive datetime). Read the fields via
+      # the component getters instead.
       class LocalDateTime < TemporalValue
         PARSE_FORMATS = [
           '%Y-%m-%d %H:%M:%S.%N',
@@ -28,35 +34,54 @@ module Neo4j
 
         def self.from_epoch(epoch_seconds, nanoseconds) = new(epoch_seconds, nanoseconds)
 
+        # Store the Time's wall clock (its date and time-of-day *in its own
+        # zone*), dropping the zone. We read that wall clock off the instant
+        # using the offset the Time already carries — we never invent a zone,
+        # so from_time(t) and from_time(t.utc) differ (they show different
+        # clocks). epoch_seconds encodes it as-if-UTC per the class contract.
         def self.from_time(time)
-          new(time.to_i, ((time.to_f - time.to_i) * NANOS_PER_SECOND).round)
+          new(time.to_i + time.utc_offset, time.nsec)
         end
 
         def self.parse(string)
           # Strip trailing timezone if present — naive datetime ignores it.
-          naive = string.sub(/[Z+\-]\d{2}:?\d{2}?$/, '')
-          time = PARSE_FORMATS.lazy.filter_map { |fmt| ::Time.strptime(naive, fmt) rescue nil }.first
+          naive = string.sub(/[Z+-]\d{2}:?\d{2}?$/, '')
+          time = PARSE_FORMATS.lazy.filter_map do |fmt|
+            ::Time.strptime(naive, fmt)
+          rescue StandardError
+            nil
+          end.first
           raise ArgumentError, "Invalid LocalDateTime format: #{string}" unless time
-          from_time(::Time.utc(*time_components(time)))
-        end
 
-        def self.time_components(time)
-          [time.year, time.month, time.day, time.hour, time.min, time.sec, time.subsec * 1_000_000]
+          from_time(time)
         end
-        private_class_method :time_components
 
-        def to_time
-          ::Time.at(@epoch_seconds, @nanoseconds.to_i, :nanosecond)
-        end
+        def year       = wall_clock.year
+        def month      = wall_clock.month
+        def day        = wall_clock.day
+        def hour       = wall_clock.hour
+        def minute     = wall_clock.min
+        def second     = wall_clock.sec
+        def nanosecond = @nanoseconds
 
-        # Add a numeric or ActiveSupport::Duration. Sub-second precision
-        # preserved by going through to_f.
-        def +(seconds)
-          self.class.from_time(to_time + seconds.to_f)
+        # Add a numeric or ActiveSupport::Duration. A wall clock has no DST,
+        # so this is plain second arithmetic; sub-second precision preserved.
+        def +(other)
+          total = (@epoch_seconds * NANOS_PER_SECOND) + @nanoseconds +
+                  (other.to_f * NANOS_PER_SECOND).round
+          self.class.new(total / NANOS_PER_SECOND, total % NANOS_PER_SECOND)
         end
 
         def to_s
-          to_time.strftime('%Y-%m-%d %H:%M:%S.%N')
+          wall_clock.strftime('%Y-%m-%d %H:%M:%S.%N')
+        end
+
+        private
+
+        # epoch_seconds read back as its wall clock. UTC by construction, so
+        # the components never depend on the host TZ.
+        def wall_clock
+          ::Time.at(@epoch_seconds, @nanoseconds.to_i, :nanosecond, in: 'UTC')
         end
       end
     end

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

@@ -16,6 +16,14 @@ module Neo4j
 
         def self.from_nanos(nanoseconds) = new(nanoseconds)
 
+        # Build from a Ruby Time, taking its displayed wall clock (so the
+        # host zone / .utc of the Time decides which time-of-day is captured).
+        # Mirrors LocalDateTime.from_time.
+        def self.from_time(time)
+          new(time.hour * NANOS_PER_HOUR + time.min * NANOS_PER_MINUTE +
+              time.sec * NANOS_PER_SECOND + time.nsec)
+        end
+
         # Accepts "12:34:56.123456789" or any string containing such a
         # time component (so a full datetime works too — we just take the
         # time fields).
@@ -34,15 +42,15 @@ module Neo4j
         end
         private_class_method :parse_nanos
 
-        def hour       = (@nanoseconds / NANOS_PER_HOUR) % 24
-        def minute     = (@nanoseconds / NANOS_PER_MINUTE) % 60
-        def second     = (@nanoseconds / NANOS_PER_SECOND) % 60
+        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 by going through to_f (NOT to_i, which dropped 0.5s).
-        def +(seconds)
-          self.class.new(@nanoseconds + (seconds.to_f * NANOS_PER_SECOND).round)
+        def +(other)
+          self.class.new(@nanoseconds + (other.to_f * NANOS_PER_SECOND).round)
         end
 
         def to_s

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

@@ -19,10 +19,16 @@ module Neo4j
 
         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:]*)?/)
+          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,
@@ -32,22 +38,22 @@ module Neo4j
 
         def self.parse_offset(str)
           return 0 if str == 'Z'
-          raise ArgumentError, "Invalid timezone offset: #{str}" unless str =~ /^([+\-])(\d{2}):?(\d{2})?$/
+          raise ArgumentError, "Invalid timezone offset: #{str}" unless str =~ /^([+-])(\d{2}):?(\d{2})?$/
 
-          sign = $1 == '+' ? 1 : -1
-          sign * ($2.to_i * 3600 + ($3 || 0).to_i * 60)
+          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
 
-        def hour       = (@nanoseconds / NANOS_PER_HOUR) % 24
-        def minute     = (@nanoseconds / NANOS_PER_MINUTE) % 60
-        def second     = (@nanoseconds / NANOS_PER_SECOND) % 60
+        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 +(seconds)
-          self.class.new(@nanoseconds + (seconds.to_f * NANOS_PER_SECOND).round, @tz_offset_seconds)
+        def +(other)
+          self.class.new(@nanoseconds + (other.to_f * NANOS_PER_SECOND).round, @tz_offset_seconds)
         end
 
         def to_s
@@ -66,6 +72,7 @@ module Neo4j
         # <=>; == 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
 

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

@@ -8,10 +8,10 @@ module Neo4j
         attr_reader :srid, :x, :y, :z
 
         # 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)
+        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(srid: nil, x: nil, y: nil, z: nil, longitude: nil, latitude: nil, height: nil)
           # Handle longitude/latitude aliases for x/y

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

@@ -13,8 +13,8 @@ module Neo4j
 
         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
+        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"
@@ -26,6 +26,7 @@ module Neo4j
 
         def <=>(other)
           return nil unless other.is_a?(self.class)
+
           significant <=> other.significant
         end
 

data/lib/neo4j/driver/version.rb

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

data/lib/neo4j/driver.rb

@@ -65,7 +65,7 @@ Java::OrgNeo4jDriverInternal::EagerResultValue.prepend Neo4j::Driver::Ext::Inter
 Java::OrgNeo4jDriverInternal::InternalDriver.prepend Neo4j::Driver::Ext::InternalDriver
 Java::OrgNeo4jDriverInternal::InternalEntity.include Neo4j::Driver::Ext::InternalEntity
 Java::OrgNeo4jDriverInternal::InternalNode.prepend Neo4j::Driver::Ext::InternalNode
-Java::OrgNeo4jDriverInternal::InternalNotificationSeverity.include  Neo4j::Driver::Ext::Internal::InternalNotificationSeverity
+Java::OrgNeo4jDriverInternal::InternalNotificationSeverity.include Neo4j::Driver::Ext::Internal::InternalNotificationSeverity
 Java::OrgNeo4jDriverInternal::InternalPath.include Neo4j::Driver::Ext::StartEndNaming
 Java::OrgNeo4jDriverInternal::InternalPath::SelfContainedSegment.include Neo4j::Driver::Ext::StartEndNaming
 Java::OrgNeo4jDriverInternal::InternalRecord.prepend Neo4j::Driver::Ext::InternalRecord

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-ruby-driver
 version: !ruby/object:Gem::Version
-  version: 6.2.1.beta.1
+  version: 6.2.1.beta.2
 platform: java
 authors:
 - Neo4j Driver Team
@@ -37,76 +37,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.6'
-- !ruby/object:Gem::Dependency
-  name: csv
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: ffaker
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.13'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.13'
-- !ruby/object:Gem::Dependency
-  name: rspec-its
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: jar-dependencies
   requirement: !ruby/object:Gem::Requirement
@@ -240,7 +170,8 @@ files:
 homepage: https://github.com/neo4jrb/neo4j-ruby-driver
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib