neo4j-ruby-driver 4.4.0-java

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalSession
+        extend AutoClosable
+        include ConfigConverter
+        include ExceptionCheckable
+        include RunOverride
+
+        auto_closable :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|
+            check do
+              super(->(tx) { Struct::Wrapper.new(reverse_check { block.call(tx) }) }, to_java_config(Neo4j::Driver::TransactionConfig, config)).object
+            end
+          end
+        end
+
+        # end work around
+
+        def run(statement, parameters = {}, config = {})
+          check do
+            java_method(:run, [org.neo4j.driver.Query, org.neo4j.driver.TransactionConfig])
+              .call(to_statement(statement, parameters), to_java_config(Neo4j::Driver::TransactionConfig, config))
+          end
+        end
+
+        def begin_transaction(**config)
+          check { super(to_java_config(Neo4j::Driver::TransactionConfig, config)) }
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      class Logger
+        include org.neo4j.driver.Logger
+        include org.neo4j.driver.Logging
+
+        delegate :debug?, to: :@active_support_logger
+
+        def initialize(active_support_logger)
+          @active_support_logger = active_support_logger
+        end
+
+        def getLog(_name)
+          self
+        end
+        alias get_log getLog
+
+        def error(*args)
+          add(::Logger::ERROR, format(*args))
+        end
+
+        def info(*args)
+          add(::Logger::INFO, format(*args))
+        end
+
+        def warn(*args)
+          add(::Logger::WARN, format(*args))
+        end
+
+        def debug(*args)
+          add(::Logger::DEBUG, format(*args))
+        end
+
+        alias trace debug
+
+        def trace_enabled?
+          debug?
+        end
+
+        def debug_enabled
+          debug?
+        end
+
+        private
+
+        def add(level, *args)
+          @active_support_logger.add(level) { format(*args) }
+        end
+
+        def format(*args)
+          args.unshift('%s%n%s') if args.last.is_a? java.lang.Throwable
+          java.lang.String.format(*args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module MapConverter
+        def to_h
+          java_method(:asMap, [java.util.function.Function]).call(&:itself).to_hash
+            .transform_values!(&:as_ruby_object).symbolize_keys!
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module NeoConverter
+        private
+
+        def to_neo(object, skip_unknown: false)
+          case object
+          when Hash
+            object.map { |key, value| [key.to_s, to_neo(value)] }.to_h
+          when Types::Path
+            Exceptions::ClientException.unable_to_convert(object)
+          when Enumerable
+            object.map(&method(:to_neo))
+          when String
+            object.encoding == Encoding::BINARY ? object.to_java_bytes : object
+          when ActiveSupport::Duration
+            Java::OrgNeo4jDriverInternal::InternalIsoDuration.new(
+              *Driver::Internal::DurationNormalizer.normalize(object)
+            )
+          when Types::Point
+            Java::OrgNeo4jDriver::Values.point(object.srid, *object.coordinates)
+          when Types::OffsetTime
+            Java::JavaTime::OffsetTime.of(object.hour, object.min, object.sec,
+                                          object.nsec, Java::JavaTime::ZoneOffset.of_total_seconds(object.utc_offset))
+          when Types::LocalTime
+            Java::JavaTime::LocalTime.of(object.hour, object.min, object.sec, object.nsec)
+          when Types::LocalDateTime
+            Java::JavaTime::LocalDateTime.of(object.year, object.month, object.day, object.hour, object.min, object.sec,
+                                             object.nsec)
+          when ActiveSupport::TimeWithZone
+            to_zoned_date_time(object, object.time_zone.tzinfo.identifier)
+          when Time, DateTime
+            to_zoned_date_time(object, object.formatted_offset)
+          when Date
+            Java::JavaTime::LocalDate.of(object.year, object.month, object.day)
+          when Symbol
+            object.to_s
+          when nil, true, false, Integer, Float
+            object
+          else
+            if skip_unknown
+              object
+            else
+              raise Exceptions::ClientException.unable_to_convert(object)
+            end
+          end
+        end
+
+        def to_zoned_date_time(object, zone)
+          Java::JavaTime::ZonedDateTime.of(object.year, object.month, object.day, object.hour, object.min, object.sec,
+                                           object.nsec, Java::JavaTime::ZoneId.of(zone))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Query
+        def parameters
+          super.as_ruby_object
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module RubyConverter
+        include MapConverter
+
+        def as_ruby_object
+          case type_constructor
+          when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::LIST
+            values(&:itself).map(&:as_ruby_object)
+          when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::MAP
+            to_h
+          when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::DATE
+            date = as_local_date
+            Date.new(date.year, date.month_value, date.day_of_month)
+          when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::DURATION
+            ActiveSupport::Duration.parse(as_iso_duration.to_s)
+          when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::POINT
+            point = as_point
+            Types::Point.new(srid: point.srid, x: point.x, y: point.y, z: nullable(point.z))
+          when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::BYTES
+            String.from_java_bytes(as_byte_array).force_encoding(Encoding::BINARY)
+          when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::TIME
+            Types::OffsetTime.parse(as_offset_time.to_string)
+          when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::LOCAL_TIME
+            Types::LocalTime.parse(as_local_time.to_string)
+          when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::LOCAL_DATE_TIME
+            Types::LocalDateTime.parse(as_local_date_time.to_string)
+          when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::DATE_TIME
+            to_time
+          else
+            as_object
+          end
+        end
+
+        private
+
+        def to_time
+          time = as_zoned_date_time
+          zone_id = time.zone.id
+          if /^Z|[+\-][0-9]{2}:[0-9]{2}$/.match?(zone_id)
+            Time.parse(time.to_string)
+          else
+            instant = time.to_instant
+            Time.at(instant.epoch_second, instant.nano, :nsec).in_time_zone(TZInfo::Timezone.get(zone_id))
+          end
+        end
+
+        def nullable(double)
+          double unless double == java.lang.Double::NaN
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module RunOverride
+        include NeoConverter
+
+        def close
+          check { super }
+        end
+
+        private
+
+        def to_statement(text, parameters)
+          Neo4j::Driver::Internal::Validator.require_hash_parameters!(parameters)
+          Neo4j::Driver::Query.new(text, to_neo(parameters || {}))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module StartEndNaming
+        def start_node
+          java_send(:start)
+        end
+
+        def end_node
+          java_send(:end)
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/keys'
+require 'date'
+require 'loader'
+require 'neo4j-ruby-driver_jars'
+
+Loader.load
+
+module Neo4j
+  module Driver
+    include_package 'org.neo4j.driver'
+
+    Record = Java::OrgNeo4jDriverInternal::InternalRecord
+    Result = Java::OrgNeo4jDriverInternal::InternalResult
+    Transaction = Java::OrgNeo4jDriverInternal::InternalTransaction
+
+    module Net
+      include_package 'org.neo4j.driver.net'
+    end
+
+    module Summary
+      include_package 'org.neo4j.driver.summary'
+    end
+
+    module Types
+      Entity = Java::OrgNeo4jDriverInternal::InternalEntity
+      Node = Java::OrgNeo4jDriverInternal::InternalNode
+      Path = Java::OrgNeo4jDriverInternal::InternalPath
+      Relationship = Java::OrgNeo4jDriverInternal::InternalRelationship
+    end
+  end
+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::InternalDriver.prepend Neo4j::Driver::Ext::InternalDriver
+Java::OrgNeo4jDriverInternal::InternalEntity.include Neo4j::Driver::Ext::InternalEntity
+Java::OrgNeo4jDriverInternal::InternalNode.prepend Neo4j::Driver::Ext::InternalNode
+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
+Java::OrgNeo4jDriverInternal::InternalRelationship.prepend Neo4j::Driver::Ext::InternalRelationship
+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::OrgNeo4jDriverInternalAsync::InternalAsyncSession.prepend Neo4j::Driver::Ext::Internal::Async::InternalAsyncSession
+Java::OrgNeo4jDriverInternalCluster::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::OrgNeo4jDriverInternalSummary::InternalResultSummary.prepend Neo4j::Driver::Ext::Internal::Summary::InternalResultSummary
+Java::OrgNeo4jDriverInternalValue::ValueAdapter.include Neo4j::Driver::Ext::RubyConverter

data/lib/loader.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+
+class Loader
+  def self.load
+    loader = Zeitwerk::Loader.new
+    loader.tag = 'neo4j-ruby-driver'
+    loader.push_dir(File.expand_path(__dir__))
+    loader.push_dir(File.dirname(File.dirname(caller_locations(1..1).first.path)))
+    yield loader if block_given?
+    loader.ignore(File.expand_path('neo4j-*-driver_jars.rb', __dir__))
+    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', __dir__))
+    loader.setup
+    loader.eager_load
+  end
+end

data/lib/neo4j/driver/auto_closable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module AutoClosable
+      def auto_closable(*methods)
+        prepend with_block_definer(methods)
+      end
+
+      private
+
+      def with_block_definer(methods)
+        Module.new do
+          methods.each do |method|
+            define_method(method) do |*args, **kwargs, &block|
+              closable = super(*args, **kwargs)
+              if block
+                begin
+                  block.arity.zero? ? closable.instance_eval(&block) : block.call(closable)
+                ensure
+                  closable&.close
+                end
+              else
+                closable
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # Failed to authenticate the driver to the server due to bad credentials provided.
+      # When this error happens, the error could be recovered by closing the current driver and restart a new driver with
+      # the correct credentials.
+
+      # @since 1.1
+      class AuthenticationException < SecurityException
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # The authorization info maintained on the server has expired. The client should reconnect.
+      # <p>
+      # Error code: Neo.ClientError.Security.AuthorizationExpired
+      class AuthorizationExpiredException < SecurityException
+        DESCRIPTION = 'Authorization information kept on the server has expired, this connection is no longer valid.'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class CertificateException
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # A <em>ClientException</em> indicates that the client has carried out an operation incorrectly.
+      # The error code provided can be used to determine further detail for the problem.
+      # @since 1.0
+      class ClientException < Neo4jException
+        class << self
+          def unable_to_convert(object)
+            raise self, "Unable to convert #{object.class.name} to Neo4j Value."
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # Indicates that read timed out due to it taking longer than the server-supplied timeout value via the {@code connection.recv_timeout_seconds} configuration
+      # hint. The server might provide this value to clients to let them know when a given connection may be considered broken if client does not get any
+      # communication from the server within the specified timeout period. This results in the server being removed from the routing table.
+      class ConnectionReadTimeoutException < ServiceUnavailableException
+        INSTANCE = new('Connection read timed out due to it taking longer than the server-supplied timeout value via configuration hint.')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # A <em>DatabaseException</em> indicates that there is a problem within the underlying database.
+      # The error code provided can be used to determine further detail for the problem.
+      # @since 1.0
+      class DatabaseException < Neo4jException
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # An error has happened while getting routing table with a remote server.
+      # While this error is not fatal and we might be able to recover if we continue trying on another server.
+      # If we fail to get a valid routing table from all routing servers known to this driver,
+      # then we will end up with a fatal error {@link ServiceUnavailableException}.
+
+      # If you see this error in your logs, it is safe to ignore if your cluster is temporarily changing structure during that time.
+      class DiscoveryException < Neo4jException
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # This error indicate a fatal problem to obtain routing tables such as the routing table for a specified database does not exist.
+      # This exception should not be retried.
+      # @since 4.0
+      class FatalDiscoveryException < ClientException
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class IllegalStateException < RuntimeError
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class Neo4jException < RuntimeError
+        attr_reader :code, :suppressed
+
+        def initialize(*args)
+          @code = args.shift if args.count > 1
+          message = args.shift
+          @suppressed = args.shift
+          super(message)
+        end
+
+        def add_suppressed(exception)
+          (@suppressed ||= []) << exception
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      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.'
+        NO_MORE = 'No more records'
+        NO_PEEK_PAST = 'Cannot peek past the last record'
+
+        class << self
+          def empty
+            new(EMPTY)
+          end
+
+          def too_many
+            new(TOO_MANY)
+          end
+
+          def no_more
+            new(NO_MORE)
+          end
+
+          def no_peek_past
+            new(NO_PEEK_PAST)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # A signal that the contract for client-server communication has broken down.
+      # The user should contact support and cannot resolve this his or herself.
+      class ProtocolException < Neo4jException
+        CODE = "Protocol violation: "
+
+        def initialize(message, e)
+          super("#{CODE}message", e)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # A user is trying to access resources that are no longer valid due to
+      # the resources have already been consumed or
+      # the {@link QueryRunner} where the resources are created has already been closed.
+      class ResultConsumedException < ClientException
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # Failed to communicate with the server due to security errors.
+      # When this type of error happens, the security cause of the error should be fixed to ensure the safety of your data.
+      # Restart of server/driver/cluster might be required to recover from this error.
+      # @since 1.1
+      class SecurityException < ClientException
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # An <em>ServiceUnavailableException</em> indicates that the driver cannot communicate with the cluster.
+      # @since 1.1
+      class ServiceUnavailableException < Neo4jException
+      end
+    end
+  end
+end