neo4j-ruby-driver 5.7.0.alpha.4 → 6.0.3.alpha.0-java

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
+            Driver::Internal::DurationNormalizer.create(*%i[months days seconds nanoseconds].map(&as_object.method(:send)))
+          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/{ruby → jruby}/neo4j/driver/version.rb

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

data/jruby/neo4j/driver.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/keys'
+require 'neo4j-ruby-driver_jars'
+require 'neo4j-ruby-driver_loader'
+
+module Neo4j
+  module Driver
+    Loader.load
+
+    include_package 'org.neo4j.driver'
+
+    EagerResult = Java::OrgNeo4jDriverInternal::EagerResultValue
+    Record = Java::OrgNeo4jDriverInternal::InternalRecord
+    Result = Java::OrgNeo4jDriverInternal::InternalResult
+    Transaction = Java::OrgNeo4jDriverInternal::DelegatingTransactionContext
+
+    module Internal
+      java_import org.neo4j.driver.internal.shaded.bolt.connection.DatabaseName
+    end
+
+    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::GraphDatabase.singleton_class.prepend Neo4j::Driver::Ext::GraphDatabase
+Java::OrgNeo4jDriver::Query.prepend Neo4j::Driver::Ext::Query
+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
+Java::OrgNeo4jDriverInternal::InternalNotificationSeverity.delegate :name, to: :type
+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::OrgNeo4jDriverInternal::DelegatingTransactionContext.prepend Neo4j::Driver::Ext::Internal::AbstractQueryRunner
+Java::OrgNeo4jDriverInternalAsync::InternalAsyncSession.prepend Neo4j::Driver::Ext::Internal::Async::InternalAsyncSession
+Java::OrgNeo4jDriverInternalShadedBoltConnectionRoutedImplCluster::RoutingTableRegistryImpl.include Neo4j::Driver::Ext::Internal::Cluster::RoutingTableRegistryImpl
+# Java::OrgNeo4jDriverInternalCursor::DisposableAsyncResultCursor.prepend Neo4j::Driver::Ext::Internal::Cursor::DisposableAsyncResultCursor
+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
+Java::OrgNeo4jDriverInternalValue::ValueAdapter.include Neo4j::Driver::Ext::RubyConverter

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/exceptions/neo4j_exception.rb

@@ -7,14 +7,14 @@ module Neo4j
         attr_reader :code, :suppressed
 
         def initialize(*args)
-          @code = args.shift if args.count > 1
-          message = args.shift
-          @suppressed = args.shift
-          super(message)
+          args, exceptions = args.partition { |arg| arg.is_a?(String) }
+          super(args.pop)
+          @code = args.pop
+          add_suppressed(*exceptions)
         end
 
-        def add_suppressed(exception)
-          (@suppressed ||= []) << exception
+        def add_suppressed(*exceptions)
+          (@suppressed ||= []).concat(exceptions) if exceptions.any?
         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