neo4j-ruby-driver 6.0.3.alpha.0-java → 6.2.1.beta.2-java

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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver::Ext
-  module Internal
-    module Cluster
-      module RoutingTableRegistryImpl
-        def routing_table_handler(database)
-          get_routing_table_handler(org.neo4j.driver.internal.bolt.api.DatabaseName.database(database)).then do |it|
-            it.get if it.present?
-          end
-        end
-      end
-    end
-  end
-end

data/jruby/neo4j/driver/ext/internal/cursor/disposable_async_result_cursor.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j::Driver::Ext
-  module Internal
-    module Cursor
-      module DisposableAsyncResultCursor
-        include AsyncConverter
-
-        def next_async
-          to_future(super)
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module Neo4j
-  module Driver
-    module Ext
-      module Internal
-        class DriverFactory < org.neo4j.driver.internal.DriverFactory
-          def initialize(&domain_name_resolver)
-            super()
-            @domain_name_resolver = ->(name) do
-              domain_name_resolver.call(name).map do |addr|
-                java.net.InetAddress.get_by_name(addr)
-              rescue java.net.UnknownHostException => e
-                raise java.lang.RuntimeException.new(e)
-              end
-            end
-          end
-
-          def getDomainNameResolver
-            @domain_name_resolver
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Ext
-      module Internal
-        module Summary
-          module InternalResultSummary
-            java_import org.neo4j.driver.summary.QueryType
-
-            %i[result_available_after result_consumed_after].each do |method|
-              define_method(method) do
-                super(Java::JavaUtilConcurrent::TimeUnit::MILLISECONDS).then { |val| val unless val == -1 }
-              end
-            end
-
-            def query_type
-              case super
-              when QueryType::READ_ONLY
-                Driver::Summary::QueryType::READ_ONLY
-              when QueryType::READ_WRITE
-                Driver::Summary::QueryType::READ_WRITE
-              when QueryType::WRITE_ONLY
-                Driver::Summary::QueryType::WRITE_ONLY
-              when QueryType::SCHEMA_WRITE
-                Driver::Summary::QueryType::SCHEMA_WRITE
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Ext
-      module InternalDriver
-        extend AutoCloseable
-        include ConfigConverter
-        include ExceptionCheckable
-        include AsyncConverter
-
-        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])
-            .call(to_java_config(Neo4j::Driver::SessionConfig, **session_config))
-        end
-
-        def async_session(**session_config)
-          java_method(:asyncSession, [org.neo4j.driver.SessionConfig])
-            .call(to_java_config(Neo4j::Driver::SessionConfig, **session_config))
-        end
-
-        def close_async
-          to_future(super)
-        end
-
-        def verify_connectivity
-          check { super }
-        end
-
-        def verify_authentication(auth_token)
-          check { super }
-        end
-
-        def supports_session_auth?
-          check { supports_session_auth }
-        end
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-# 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

@@ -1,59 +0,0 @@
-# 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/lib/neo4j/driver/internal/bolt_server_address.rb

@@ -1,97 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    # Holds a host and port pair that denotes a Bolt server address.
-    class BoltServerAddress
-      attr_reader :host, :connection_host, :port
-      delegate :hash, to: :attributes
-
-      DEFAULT_PORT = 7687
-
-      class << self
-        def host_from(uri)
-          uri&.host || (raise invalid_address_format(uri))
-        end
-
-        def port_from(uri)
-          uri&.port || DEFAULT_PORT
-        end
-
-        def uri_from(address)
-          scheme_split = address.split('://')
-
-          if scheme_split.length == 1
-            # URI can't parse addresses without scheme, prepend fake "bolt://" to reuse the parsing facility
-            scheme = 'bolt://'
-            host_port = host_port_from(scheme_split.first)
-          elsif scheme_split.length == 2
-            scheme = "#{scheme_split.first}://"
-            host_port = host_port_from(scheme_split.second)
-          else
-            raise invalid_address_format(address)
-          end
-
-          URI(scheme + host_port)
-        end
-
-        def host_port_from(address)
-          # expected to be an IPv6 address like [::1] or [::1]:7687
-          return address if address.start_with?('[')
-
-          contains_single_colon = address.index(':') == address.rindex(':')
-
-          # expected to be an IPv4 address with or without port like 127.0.0.1 or 127.0.0.1:7687
-          return address if contains_single_colon
-
-          # address contains multiple colons and does not start with '['
-          # expected to be an IPv6 address without brackets
-          "[#{address}]"
-        end
-
-        def invalid_address_format(address)
-          ArgumentError.new("Invalid address format #{address}")
-        end
-
-        def require_valid_port(port)
-          return port if port >= 0 && port <= 65_535
-
-          raise ArgumentError, "Illegal port: #{port}"
-        end
-      end
-
-      def initialize(uri: nil, host: self.class.host_from(uri), port: self.class.port_from(uri), connection_host: host)
-        @host = Validator.require_non_nil!(host)
-        @connection_host = Validator.require_non_nil!(connection_host)
-        @port = self.class.require_valid_port(port)
-      end
-
-      LOCAL_DEFAULT = new(host: 'localhost', port: DEFAULT_PORT)
-
-      def self.from(address)
-        address.is_a?(BoltServerAddress) ? address : new(host: address.host, port: address.port)
-      end
-
-      def ==(other)
-        attributes == other&.attributes
-      end
-
-      alias eql? ==
-
-      def to_s
-        "#{host}#{"(#{connection_host})" unless host == connection_host}:#{port}"
-      end
-
-      # Create a stream of unicast addresses.
-      # <p>
-      # While this implementation just returns a stream of itself, the subclasses may provide multiple addresses.
-
-      # @return stream of unicast addresses.
-      def unicast_stream
-        Set[self]
-      end
-
-      def attributes
-        [@host, @connection_host, @port]
-      end
-    end
-  end
-end

data/lib/neo4j/driver/synchronizable.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Synchronizable
-      def sync(*methods)
-        prepend with_sync_wrapper(methods)
-      end
-
-      private
-
-      def with_sync_wrapper(methods)
-        Module.new do
-          methods.each do |method|
-            define_method(method) do |*args, **kwargs, &block|
-              Sync { super(*args, **kwargs, &block) }
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Neo4j
-  module Driver
-    module Types
-      class Time
-        include Comparable
-
-        delegate :hash, :to_a, to: :significant
-
-        class << self
-          def parse(date)
-            new(::Time.parse(date))
-          end
-        end
-
-        def initialize(time)
-          @time = time
-        end
-
-        def significant
-          self.class.significant_fields.map(&method(:send))
-        end
-
-        def <=>(other)
-          return unless other.is_a?(self.class)
-
-          self.class.significant_fields.reduce(0) do |acc, elem|
-            acc.zero? ? send(elem) <=> other.send(elem) : (break acc)
-          end
-        end
-
-        def ==(other)
-          other.is_a?(self.class) && self.class.significant_fields.all? { |elem| send(elem) == other.send(elem) }
-        end
-
-        alias eql? ==
-
-        def +(numeric)
-          self.class.new(@time + numeric)
-        end
-      end
-    end
-  end
-end